Firesphere\SolrSearch\Helpers\DataResolver

Complexity

Total Complexity

26

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	cannotIdentifyException()	0	8	2
A	resolveDataObject()	0	21	6
A	resolveList()	0	16	4
A	__construct()	0	8	3
A	resolveArrayData()	0	10	3
A	identify()	0	16	5
A	resolveField()	0	13	3

<?php

namespace Firesphere\SolrSearch\Helpers;

use Exception;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\FieldType\DBField;
use SilverStripe\ORM\SS_List;
use SilverStripe\View\ArrayData;

class DataResolver
{
    protected $component;
    protected $columns = [];
    protected $columnName = '';

    public function __construct($component, $columns = [])
    {
        if (!is_array($columns)) {
            $columns = array_filter(explode('.', $columns));
        }
        $this->columns = $columns;
        $this->component = $component;
        $this->columnName = $this->columns ? array_shift($this->columns) : null;
    }

    /**
     * @param DataObject|ArrayData|SS_List $obj
     * @param array|string $columns
     *
     * @return mixed
     * @throws Exception
     */
    public static function identify($obj, $columns = [])
    {
        $instance = new self($obj, $columns);
        if ($obj instanceof DataObject) {
            return $instance->resolveDataObject();
        }
        if ($obj instanceof ArrayData) {
            return $instance->resolveArrayData();
        }
        if ($obj instanceof SS_List) {

$obj is always a sub-type of SilverStripe\ORM\SS_List.

            return $instance->resolveList();
        }
        if ($obj instanceof DBField) {
            return $instance->resolveField();
        }
        throw new Exception(sprintf('Class: %s, is not supported.', get_class($obj)));
    }

    /**
     * @param DataObject|ArrayData|SS_List $component
     * @param array $columns
     *
     * @return void
     * @throws Exception
     */
    protected function cannotIdentifyException($component, $columns = [])
    {
        if (!empty($columns)) {
            throw new Exception(
                sprintf(
                    'Cannot identify, "%s" from class "%s"',
                    implode('.', $columns),
                    get_class($component)
                )
            );
        }
    }

    /**
     * Resolves a Single field in the database.
     * @return mixed
     * @throws Exception
     */
    protected function resolveField()
    {
        $this->cannotIdentifyException($this->component, $this->columns);
        if ($this->columnName) {
            $method = $this->columnName;
            if (!method_exists($this->component, $method)) {
                throw new Exception(
                    sprintf('Method, "%s" not found on "%s"', $method, get_class($this->component))
                );
            }
            return $this->component->$method();
        }
        return $this->component->getValue();
    }

    /**
     * Resolves a DataObject value
     * @return mixed
     * @throws Exception
     */
    protected function resolveDataObject()
    {
        if (empty($this->columnName)) {
            return $this->component->toMap();
        }
        // Inspect component for element $relation
        if ($this->component->hasMethod($this->columnName)) {
            $relation = $this->columnName;
            return self::identify($this->component->$relation(), $this->columns);
        }
        // Inspect component has attribute
        if ($this->component->hasField($this->columnName)) {
            $data = $this->component->{$this->columnName};
            $dbObject = $this->component->dbObject($this->columnName);
            if ($dbObject && $this->columns) {
                $dbObject->setValue($data);
                return self::identify($dbObject, $this->columns);
            }
            return $data;
        }
        $this->cannotIdentifyException($this->component, [$this->columnName]);
    }

    /**
     * Resolves an ArrayData value
     * @return mixed
     * @throws Exception
     */
    public function resolveArrayData()
    {
        if (empty($this->columnName)) {
            return $this->component->toMap();
        }
        // Inspect component has attribute
        if ($this->component->hasField($this->columnName)) {
            return $this->component->{$this->columnName};
        }
        $this->cannotIdentifyException($this->component, [$this->columnName]);
    }

    /**
     * Resolves a DataList values
     * @return array|mixed
     * @throws Exception
     */
    public function resolveList()
    {
        if (empty($this->columnName)) {
            return $this->component->toNestedArray();
        }
        // Inspect $component for element $relation
        if ($this->component->hasMethod($this->columnName)) {
            $relation = $this->columnName;
            return self::identify($this->component->$relation(), $this->columns);
        }
        $data = [];
        array_unshift($this->columns, $this->columnName);
        foreach ($this->component as $component) {
            $data[] = self::identify($component, $this->columns);
        }
        return $data;
    }
}