Borobudur\Cqrs\ViewModel\Aggregate

Complexity

Total Complexity

24

Size/Duplication

Total Lines	249
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	sum()	0	9	1
A	avg()	0	4	1
A	max()	0	12	2
A	min()	0	14	3
A	count()	0	16	3
A	first()	0	6	2
A	last()	0	6	2
A	closure()	0	12	2
A	walk()	0	15	2
B	getArguments()	0	27	4
A	getMethodName()	0	4	1

<?php
/*
 * This file is part of the Borobudur-Cqrs package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Cqrs\ViewModel;

use Borobudur\Cqrs\Exception\InvalidArgumentException;
use Closure;
use ReflectionFunction;
use ReflectionObject;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/20/15
 */
class Aggregate
{
    /**
     * @var array
     */
    private $data;

    /**
     * @var ReflectionObject
     */
    private $reflection;

    /**
     * @var string
     */
    private $prefixMethod;

    /**
     * @var ViewModelInterface
     */
    private $viewModel;

    /**
     * Constructor.
     *
     * @param array              $data
     * @param ViewModelInterface $viewModel
     * @param ReflectionObject   $reflection
     * @param string             $prefixMethod
     */
    public function __construct(array $data, ViewModelInterface $viewModel, ReflectionObject $reflection, $prefixMethod)
    {
        $this->data = $data;
        $this->reflection = $reflection;
        $this->prefixMethod = $prefixMethod;
        $this->viewModel = $viewModel;
    }

    /**
     * Data summary.
     *
     * @param string $fields
     *
     * @return int|float
     */
    public function sum($fields)
    {
        $total = 0;
        $this->walk($fields, function () use (&$total) {
            $total += array_sum(func_get_args());
        });

        return $total;
    }

    /**
     * Data average.
     *
     * @param string $fields
     *
     * @return float
     */
    public function avg($fields)
    {
        return $this->sum($fields) / count($this->data);
    }

    /**
     * Data maximum.
     *
     * @param string $fields
     *
     * @return int
     */
    public function max($fields)
    {
        $max = 0;
        $this->walk($fields, function () use (&$max) {
            $cur = max(func_get_args());
            if ($cur > $max) {
                $max = $cur;
            }
        });

        return $max;
    }

    /**
     * Data minimum.
     *
     * @param string $fields
     *
     * @return int
     */
    public function min($fields)
    {
        $min = null;
        $this->walk($fields, function () use (&$min) {
            $cur = min(func_get_args());
            if (null === $min) {
                $min = $cur;
            } elseif ($cur < $min) {
                $min = $cur;
            }
        });

        return $min;
    }

    /**
     * Data count.
     *
     * @param string $fields
     *
     * @return int
     */
    public function count($fields)
    {
        if (empty($fields) || '*' === $fields) {
            $this->viewModel->setForceSingle();

            return count($this->data);
        }

        $num = 0;

        $this->walk($fields, function () use (&$num) {
            $num += count(array_filter(func_get_args()));
        });

        return $num;
    }

    /**
     * Get first data.
     *
     * @return array|null
     */
    public function first()
    {
        $this->viewModel->setForceSingle();

        return count($this->data) > 0 ? $this->data[0] : null;
    }

    /**
     * Get last data.
     *
     * @return array|null
     */
    public function last()
    {
        $this->viewModel->setForceSingle();

        return count($this->data) > 0 ? end($this->data) : null;
    }

    /**
     * Custom aggregate with closure.
     *
     * @param Closure $callback
     *
     * @return bool
     */
    public function closure(Closure $callback)
    {
        $reflection = new ReflectionFunction($callback);
        $properties = $reflection->getParameters();
        $args = array();

        foreach ($properties as $prop) {
            $args[] = $prop->getName();
        }

        return $this->walk(implode(',', $args), $callback);
    }

    /**
     * Walking into collection.
     *
     * @param string  $fields
     * @param Closure $callback
     *
     * @return bool
     */
    private function walk($fields, Closure $callback)
    {
        if (empty($fields)) {
            throw new InvalidArgumentException(sprintf('Cannot walk with empty fields.'));
        }

        $this->viewModel->setForceSingle();
        $fields = explode(',', trim($fields));

        return array_walk($this->data, function (array $record) use ($fields, $callback) {
            $args = $this->getArguments($fields, $record);

            return call_user_func_array($callback, $args);
        });
    }

    /**
     * Get args.
     *
     * @param array $params
     * @param array $record
     *
     * @return array
     */
    private function getArguments(array $params, array $record)
    {
        $args = array();
        foreach ($params as $var) {
            $var = trim($var);
            $method = $this->getMethodName($var);
            if ($this->reflection->hasMethod($method)) {
                $args[] = $this->reflection->getMethod($method)->invokeArgs(
                    $this->viewModel, $this->viewModel->buildViewModelArgs($this->data, $record, $var)
                );

                continue;
            }

            if (isset($record[$var])) {
                $args[] = $record[$var];
                continue;
            }

            throw new InvalidArgumentException(sprintf(
                'Field "%s" is not defined.',
                $var
            ));
        }

        return $args;
    }

    /**
     * Get method name.
     *
     * @param string $name
     *
     * @return string
     */
    private function getMethodName($name)
    {
        return $this->prefixMethod.ucfirst($name);
    }
}