AbstractSource - Code Metrics - Inspection of "Modified `CollectionLoader` and `AbstractSource`" - locomotivemtl/charcoal-core - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( 000e9e...f38e71 )

unknown

created 2017-07-24 22:04 UTC

AbstractSource C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	559
Duplicated Lines	11.09 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

Metric	Value
wmc	69
lcom	1
cbo	10
dl	62
loc	559
rs	5.6445
c	0
b	0
f	0

36 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	reset()	0	8	1
A	setData()	0	13	3
A	setModel()	0	5	1
A	model()	0	9	2
A	hasModel()	0	4	1
A	setProperties()	0	8	2
A	properties()	0	4	1
A	addProperty()	15	15	3
A	setFilters()	0	8	2
A	addFilters()	0	7	2
A	filters()	0	4	1
C	addFilter()	12	40	11
A	createFilter()	0	5	1
A	setOrders()	0	8	2
A	addOrders()	0	7	2
A	orders()	0	4	1
D	addOrder()	11	36	9
A	createOrder()	0	5	1
A	setPagination()	0	15	3
A	pagination()	0	7	2
A	createPagination()	0	5	1
A	setPage()	0	10	2
A	page()	0	4	1
A	setNumPerPage()	0	10	2
A	numPerPage()	0	4	1
A	createConfig()	0	8	2
	loadItem()	0	1	?
	loadItems()	0	1	?
	saveItem()	0	1	?
	updateItem()	0	1	?
	deleteItem()	0	1	?
A	getter()	12	12	3
A	setter()	12	12	3
A	camelize()	0	4	1
A	pascalize()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AbstractSource often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AbstractSource, and based on these observations, apply Extract Interface, too.

<?php

namespace Charcoal\Source;

use Exception;
use InvalidArgumentException;

// From PSR-3
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;

// From 'charcoal-config'
use Charcoal\Config\ConfigurableInterface;
use Charcoal\Config\ConfigurableTrait;

// From 'charcoal-core'
use Charcoal\Model\ModelInterface;

use Charcoal\Source\SourceConfig;
use Charcoal\Source\SourceInterface;
use Charcoal\Source\Filter;
use Charcoal\Source\FilterInterface;
use Charcoal\Source\Order;
use Charcoal\Source\OrderInterface;
use Charcoal\Source\Pagination;
use Charcoal\Source\PaginationInterface;

/**
 * Full implementation, as abstract class, of the SourceInterface.
 */
abstract class AbstractSource implements
    SourceInterface,
    ConfigurableInterface,
    LoggerAwareInterface
{
    use ConfigurableTrait;
    use LoggerAwareTrait;

    /**
     * @var ModelInterface $model
     */
    private $model = null;

    /**
     * @var array $properties
     */
    private $properties = [];

    /**
     * Array of `Filter` objects
     * @var array $filters
     */
    protected $filters = [];

    /**
     * Array of `Order` object
     * @var array $orders
     */
    protected $orders = [];

    /**
     * The `Pagination` object
     * @var Pagination|null $pagination
     */
    protected $pagination = null;

    /**
     * @param array|\ArrayAccess $dependencies The class dependencies.
     * @return void

     */
    public function __construct($dependencies)
    {
        $this->setLogger($dependencies['logger']);
    }

    /**
     * Reset everything but the model.
     *
     * @return AbstractSource Chainable
     */
    public function reset()
    {
        $this->properties = [];
        $this->filters = [];
        $this->orders = [];
        $this->pagination = null;
        return $this;
    }

    /**
     * Initialize the source's properties with an array of data.
     *
     * @param array $data The source data.
     * @return AbstractSource Chainable
     */
    public function setData(array $data)
    {
        foreach ($data as $prop => $val) {
            $func = [$this, $this->setter($prop)];
            if (is_callable($func)) {
                call_user_func($func, $val);
                unset($data[$prop]);
            } else {
                $this->{$prop} = $val;
            }
        }
        return $this;
    }

    /**
     * Set the source's Model.
     *
     * @param ModelInterface $model The source's model.
     * @return AbstractSource Chainable
     */
    public function setModel(ModelInterface $model)
    {
        $this->model = $model;
        return $this;
    }

    /**
     * Return the source's Model.
     *
     * @throws Exception If not model was previously set.
     * @return ModelInterface
     */
    public function model()
    {
        if ($this->model === null) {
            throw new Exception(
                'No model set.'
            );
        }
        return $this->model;
    }

    /**
     * @return boolean
     */
    public function hasModel()
    {
        return ($this->model !== null);
    }

    /**
     * Set the properties of the source to fetch.
     *
     * This method accepts an array of property identifiers (property ident, as string)
     * that will, if supported, be fetched from the source.
     *
     * If no properties are set, it is assumed that all the Model's properties are to be fetched.
     *
     * @param array $properties The properties.
     * @return ColelectionLoader Chainable
     */
    public function setProperties(array $properties)
    {
        $this->properties = [];
        foreach ($properties as $p) {
            $this->addProperty($p);
        }
        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @return array
     */
    public function properties()
    {
        return $this->properties;
    }

    /**
     * @param string $property Property ident.
     * @throws InvalidArgumentException If property is not a string or empty.
     * @return SourceInterface Chainable
     */
    public function addProperty($property)

    {
        if (!is_string($property)) {
            throw new InvalidArgumentException(
                'Property must be a string.'
            );
        }
        if ($property=='') {
            throw new InvalidArgumentException(
                'Property can not be empty.'
            );
        }
        $this->properties[] = $property;
        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @param array $filters The filters to set.
     * @return SourceInterface Chainable
     */
    public function setFilters(array $filters)
    {
        $this->filters = [];
        foreach ($filters as $f) {
            $this->addFilter($f);
        }
        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @param array $filters The filters to add.
     * @return SourceInterface Chainable
     */
    public function addFilters(array $filters)
    {
        foreach ($filters as $f) {
            $this->addFilter($f);
        }
        return $this;
    }

    /**
     * @return array
     */
    public function filters()
    {
        return $this->filters;
    }

    /**
     * Add a collection filter to the loader.
     *
     * There are 3 different ways of adding a filter:
     * - as a `Filter` object, in which case it will be added directly.
     *   - `addFilter($obj);`
     * - as an array of options, which will be used to build the `Filter` object
     *   - `addFilter(['property' => 'foo', 'val' => 42, 'operator' => '<=']);`
     * - as 3 parameters: `property`, `val` and `options`
     *   - `addFilter('foo', 42, ['operator' => '<=']);`
     *
     * @param string|array|Filter $param   The filter property, or a Filter object / array.
     * @param mixed               $val     Optional: Only used if the first argument is a string.
     * @param array               $options Optional: Only used if the first argument is a string.
     * @throws InvalidArgumentException If property is not a string or empty.
     * @return SourceInterface (Chainable)
     */
    public function addFilter($param, $val = null, array $options = null)
    {
        if ($param instanceof FilterInterface) {
            $filter = $param;
        } elseif (is_array($param)) {
            $filter = $this->createFilter();
            $filter->setData($param);
        } elseif (is_string($param) && $val !== null) {
            $filter = $this->createFilter();
            $filter->setProperty($param);
            $filter->setVal($val);
            if (is_array($options)) {
                $filter->setData($options);
            }
        } else {
            throw new InvalidArgumentException(
                'Parameter must be an array or a property ident.'
            );
        }

        if ($this->hasModel()) {
            $property = $filter->property();
            if ($property) {

                $p = $this->model()->p($property);
                if ($p) {
                    if ($p->l10n()) {
                        $filter->setProperty($p->l10nIdent());
                    }

                    if ($p->multiple()) {
                        $filter->setOperator('FIND_IN_SET');
                    }
                }
            }
        }

        $this->filters[] = $filter;

        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @return FilterInterface
     */
    protected function createFilter()
    {
        $filter = new Filter();
        return $filter;
    }

    /**
     * @param array $orders The orders to set.
     * @return AbstractSource Chainable
     */
    public function setOrders(array $orders)
    {
        $this->orders = [];
        foreach ($orders as $o) {
            $this->addOrder($o);
        }
        return $this;
    }

    /**
     * @param array $orders The orders to add.
     * @return AbstractSource Chainable
     */
    public function addOrders(array $orders)
    {
        foreach ($orders as $o) {
            $this->addOrder($o);
        }
        return $this;
    }

    /**
     * @return array
     */
    public function orders()
    {
        return $this->orders;
    }

    /**
     * @param string|array|Order $param        The order property, or an Order object / array.
     * @param string             $mode         Optional.
     * @param array              $orderOptions Optional.
     * @throws InvalidArgumentException If the param argument is invalid.
     * @return SourceInterface Chainable
     */
    public function addOrder($param, $mode = 'asc', array $orderOptions = null)
    {
        if ($param instanceof OrderInterface) {
            $order = $param;
        } elseif (is_array($param)) {
            $order = $this->createOrder();
            $order->setData($param);
        } elseif (is_string($param)) {
            $order = $this->createOrder();
            $order->setProperty($param);
            $order->setMode($mode);
            if (isset($orderOptions['values'])) {
                $order->setValues($orderOptions['values']);
            }
        } else {
            throw new InvalidArgumentException(
                'Parameter must be an OrderInterface object or a property ident.'
            );
        }

        if ($this->hasModel()) {

            $property = $order->property();
            if ($property) {
                $p = $this->model()->p($property);
                if ($p) {
                    if ($p->l10n()) {
                        $order->setProperty($p->l10nIdent());
                    }
                }
            }
        }

        $this->orders[] = $order;

        return $this;
    }

    /**
     * @return OrderInterface
     */
    protected function createOrder()
    {
        $order = new Order();
        return $order;
    }

    /**
     * @param mixed $param The pagination object or array.
     * @throws InvalidArgumentException If the argument is not an object or array.
     * @return SourceInterface Chainable
     */
    public function setPagination($param)
    {
        if ($param instanceof PaginationInterface) {
            $this->pagination = $param;

        } elseif (is_array($param)) {
            $pagination = $this->createPagination();
            $pagination->setData($param);
            $this->pagination = $pagination;

        } else {
            throw new InvalidArgumentException(
                'Can not set pagination, invalid argument.'
            );
        }
        return $this;
    }

    /**
     * Get the pagination object.
     *
     * If the pagination wasn't set previously, a new (default / blank) Pagination object will be created.
     * (Always return a `PaginationInterface` object)
     *
     * @return PaginationInterface
     */
    public function pagination()
    {
        if ($this->pagination === null) {
            $this->pagination = $this->createPagination();

        }
        return $this->pagination;
    }

    /**
     * @return PaginationInterface
     */
    protected function createPagination()
    {
        $pagination = new Pagination();
        return $pagination;
    }

    /**
     * @param integer $page The page number.
     * @throws InvalidArgumentException If the page argument is not numeric.
     * @return AbstractSource Chainable
     */
    public function setPage($page)
    {
        if (!is_numeric($page)) {
            throw new InvalidArgumentException(
                'Page must be an integer.'
            );
        }
        $this->pagination()->setPage((int)$page);
        return $this;
    }

    /**
     * @return integer
     */
    public function page()
    {
        return $this->pagination()->page();
    }

    /**
     * @param integer $num The number of items to retrieve per page.
     * @throws InvalidArgumentException If the num per page argument is not numeric.
     * @return AbstractSource Chainable
     */
    public function setNumPerPage($num)
    {
        if (!is_numeric($num)) {
            throw new InvalidArgumentException(
                'Num must be an integer.'
            );
        }
        $this->pagination()->setNumPerPage((int)$num);
        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @return integer
     */
    public function numPerPage()
    {
        return $this->pagination()->numPerPage();
    }

    /**
     * ConfigurableTrait > createConfig()
     *
     * @param array $data Optional.
     * @return SourceConfig
     */
    public function createConfig(array $data = null)
    {
        $config = new SourceConfig();
        if (is_array($data)) {
            $config->merge($data);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
        }
        return $config;
    }

    /**
     * @param mixed             $ident The ID of the item to load.
     * @param StorableInterface $item  Optional item to load into.
     * @return StorableInterface
     */
    abstract public function loadItem($ident, StorableInterface $item = null);

    /**
     * @param StorableInterface|null $item The model to load items from.
     * @return array
     */
    abstract public function loadItems(StorableInterface $item = null);

    /**
     * Save an item (create a new row) in storage.
     *
     * @param StorableInterface $item The object to save.
     * @return mixed The created item ID, or false in case of an error.
     */
    abstract public function saveItem(StorableInterface $item);

    /**
     * Update an item in storage.
     *
     * @param StorableInterface $item       The object to update.
     * @param array             $properties The list of properties to update, if not all.
     * @return boolean Success / Failure
     */
    abstract public function updateItem(StorableInterface $item, array $properties = null);

    /**
     * Delete an item from storage
     *
     * @param StorableInterface $item Optional item to delete. If none, the current model object will be used..
     * @return boolean Success / Failure
     */
    abstract public function deleteItem(StorableInterface $item = null);

    /**
     * Allow an object to define how the key getter are called.
     *
     * @param string $key  The key to get the getter from.
     * @param string $case Optional. The type of case to return. camel, pascal or snake.
     * @return string The getter method name, for a given key.
     */
    protected function getter($key, $case = 'camel')

    {
        $getter = $key;

        if ($case == 'camel') {
            return $this->camelize($getter);
        } elseif ($case == 'pascal') {
            return $this->pascalize($getter);
        } else {
            return $getter;
        }
    }

    /**
     * Allow an object to define how the key setter are called.
     *
     * @param string $key  The key to get the setter from.
     * @param string $case Optional. The type of case to return. camel, pascal or snake.
     * @return string The setter method name, for a given key.
     */
    protected function setter($key, $case = 'camel')

    {
        $setter = 'set_'.$key;

        if ($case == 'camel') {
            return $this->camelize($setter);
        } elseif ($case == 'pascal') {
            return $this->pascalize($setter);
        } else {
            return $setter;
        }
    }

    /**
     * Transform a snake_case string to camelCase.
     *
     * @param string $str The snake_case string to camelize.
     * @return string The camelCase string.
     */
    private function camelize($str)
    {
        return lcfirst($this->pascalize($str));
    }

    /**
     * Transform a snake_case string to PamelCase.
     *
     * @param string $str The snake_case string to pascalize.
     * @return string The PamelCase string.
     */
    private function pascalize($str)
    {
        return implode('', array_map('ucfirst', explode('_', $str)));
    }
}


locomotivemtl / charcoal-core