LeKoala\FormElements\TomSelect

Complexity

Total Complexity

49

Size/Duplication

Total Lines	312
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	setAjaxLoad()	0	7	1
A	setTokenSeparator()	0	3	1
A	validate()	0	12	3
A	setOnNewTag()	0	4	1
A	setSubmittedValue()	0	3	1
A	getPlugin()	0	4	2
A	setValue()	0	21	6
A	getTokenSeparators()	0	3	1
A	getAllowClear()	0	3	1
A	isAjax()	0	3	2
A	removePlugin()	0	6	2
A	setTags()	0	6	2
A	extraClass()	0	3	1
A	requirements()	0	3	1
A	getAjax()	0	3	1
A	getTags()	0	3	1
A	setPlugin()	0	9	2
A	getOnNewTag()	0	3	1
B	Field()	0	38	7
A	getServerVars()	0	7	1
A	__construct()	0	5	1
A	setAjax()	0	10	1
A	Type()	0	3	1
A	setAllowClear()	0	7	2
A	setPlaceholder()	0	3	1
A	performReadonlyTransformation()	0	14	3
A	getPlaceholder()	0	3	1
A	isDisabledValue()	0	3	1

<?php

namespace LeKoala\FormElements;

use SilverStripe\ORM\DataObject;
use SilverStripe\View\Requirements;

/**
 * Implements AjaxPoweredField + TagsField
 */
trait TomSelect
{
    use BaseElement;
    use Localize;
    use Autocompleter;

    /**
     * @var boolean
     */
    protected $multiple = false;

    /**
     * Callback to create tags
     * See docs/on-new-tag.md for sample code
     *
     * @var Callable
     */
    protected $onNewTag = null;

    /**
     * @config
     *
     * @var boolean
     */
    private static $enable_requirements = true;

    /**
     * @link https://github.com/orchidjs/tom-select/blob/master/src/defaults.ts
     * @config
     * @var array
     */
    private static $default_config = [
        "valueField" => "id",
        "labelField" => "text",
        "searchField" => ["text"]
    ];

    public function __construct($name, $title = null, $source = [], $value = null)
    {
        parent::__construct($name, $title, $source, $value);
        $this->setAllowClear(true);
        $this->mergeDefaultConfig();
    }

    public function Type()
    {
        return 'tomselect';
    }

    public function extraClass()
    {
        return 'no-chosen ' . parent::extraClass();
    }

    public function getServerVars()
    {
        return [
            'queryParam' => 'q',
            'dataKey' => 'data',
            'valueField' => 'id',
            'labelField' => 'text',
        ];
    }

    public function setValue($value, $data = null)
    {
        if ($data instanceof DataObject) {
            $this->loadFromDataObject($data);
        } else {
            // For ajax, we need to add the option to the list
            $class = $this->getAjaxClass();
            if ($value && $class) {
                $arr = $value;
                if (!is_array($arr)) {
                    $arr = [$value];
                }
                foreach ($arr as $id) {
                    $record = DataObject::get_by_id($class, $id);
                    $this->addRecordToSource($record);
                }
            }

            $this->value = $value;

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

        }
        return $this;
    }

    public function setSubmittedValue($value, $data = null)
    {
        return $this->setValue($value, $data);
    }

    /**
     * Check if the given value is disabled
     * Override base function otherwise it returns false when field is disabled
     *
     * @param string $value
     * @return bool
     */
    protected function isDisabledValue($value)
    {
        return in_array($value, $this->getDisabledItems() ?? []);

It seems like getDisabledItems() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }


    public function performReadonlyTransformation()
    {
        $field = $this->castedCopy(get_class($this));

It seems like castedCopy() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if ($this->getForm()) {

It seems like getForm() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $field->setForm($this->getForm());
        }
        $field->setDisabled(true);
        $field->setSource($this->getSource());

It seems like getSource() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $field->setReadonly(true);
        // Required to properly set value if no source set
        if ($this->ajaxClass) {
            $field->setAjaxClass($this->getAjaxClass());
        }
        return $field;
    }

    public function getPlugin($plugin)
    {
        if (isset($this->config['plugins'][$plugin])) {
            return $this->config['plugins'][$plugin];
        }
    }

    public function removePlugin($plugin)
    {
        if (isset($this->config['plugins'][$plugin])) {
            unset($this->config['plugins'][$plugin]);
        }
        return $this;
    }

    public function setPlugin($plugin, $config = [])
    {
        $plugins = $this->config['plugins'] ?? [];
        if (empty($plugins)) {
            $this->config['plugins'] = $plugins;
        }
        $pluginConfig = $plugins[$plugin] ?? [];
        $this->config['plugins'][$plugin] = array_merge($pluginConfig, $config);
        return $this;
    }

    public function getTags()
    {
        return $this->getConfig('create');
    }

    public function setTags($value, $blur = true)
    {
        if ($value) {
            $this->setConfig('createOnBlur', $blur);
        }
        return $this->setConfig('create', $value);
    }

    public function getPlaceholder()
    {
        return $this->getConfig('placeholder');
    }

    public function setPlaceholder($value)
    {
        return $this->setConfig('placeholder', $value);
    }

    public function getAllowClear()
    {
        return $this->getConfig('remove_button');
    }

    public function setAllowClear($value)
    {
        // @link https://tom-select.js.org/plugins/remove-button/
        if ($value) {
            return $this->setPlugin('remove_button', ['title' => _t('TomSelect.Remove', 'Remove')]);
        } else {
            return $this->removePlugin('remove_button');
        }
    }

    public function getTokenSeparators()
    {
        return $this->getConfig('delimiter');
    }

    public function setTokenSeparator($value)
    {
        return $this->setConfig('delimiter', $value);
    }

    public function setAjaxLoad($callbackName, $valueField = "id", $labelField = "text", $searchField = "text")
    {
        $this->setConfig('load', $callbackName);
        $this->setConfig('valueField', $valueField);
        $this->setConfig('labelField', $labelField);
        $this->setConfig('searchField', $searchField);
        return $this;
    }

    public function getAjax()
    {
        return $this->getConfig('_ajax');
    }

    public function setAjax($url, $opts = [])
    {
        $ajax = array_merge([
            'url' => $url,
            'paramName' => "q",
            'params' => [
                'SecurityID' => $this->getForm()->getSecurityToken()->getValue()
            ]
        ], $opts);
        return $this->setConfig('_ajax', $ajax);
    }

    /**
     * @return boolean
     */
    public function isAjax()
    {
        return $this->ajaxClass || $this->getConfig('_ajax');
    }

    /**
     * @return Callable
     */
    public function getOnNewTag()
    {
        return $this->onNewTag;
    }

    /**
     * The callback should return the new id
     *
     * @param Callable $locale
     * @return $this
     */
    public function setOnNewTag($callback)
    {
        $this->onNewTag = $callback;
        return $this;
    }

    public function Field($properties = array())
    {
        // Set lang based on locale
        $lang = substr($this->getLocale(), 0, 2);
        if ($lang != 'en') {
            $this->setConfig('language', $lang);
        }

        if ($this->isDisabled() || $this->isReadonly()) {

It seems like isReadonly() must be provided by classes using this trait. How about adding it as abstract method to this trait?

The method isDisabled() does not exist on LeKoala\FormElements\TomSelect. Did you maybe mean isDisabledValue()?

            $this->setConfig('disabled', true);
            $this->setAllowClear(false);
        }

        // Set RTL
        $dir = $this->getScriptDir();
        if ($dir == 'rtl') {
            $this->setConfig('dir', $dir);
        }

        // Ajax wizard, needs a form to get controller link
        if ($this->ajaxClass) {
            $url = $this->Link('autocomplete');
            $this->setAjax($url);
        }

        if (self::config()->enable_requirements) {
            self::requirements();
        }

        $html = parent::Field($properties);
        $config = $this->getConfigAsJson();

        $html = str_replace("form-select", "", $html);

        // Simply wrap with custom element and set config
        $html = "<tom-select data-config='" . $config . "'>" . $html . '</tom-select>';

        return $html;
    }

    public static function requirements()
    {
        Requirements::javascript("lekoala/silverstripe-form-elements: client/custom-elements/tom-select.min.js");
    }

    /**
     * Validate this field
     *
     * @param Validator $validator

The type LeKoala\FormElements\Validator was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return bool
     */
    public function validate($validator)
    {
        // Tags can be created on the fly and cannot be validated
        if ($this->getTags()) {
            return true;
        }

        if ($this->isAjax()) {
            return true;
        }

        return parent::validate($validator);
    }
}