PaginatorTrait::getPaginator() - Code Metrics - Inspection of "Merge pull request #115 from spiral/develop" - spiral/components - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 697d04...680e31 )

by Anton

created 2016-03-14 15:39 UTC

PaginatorTrait::getPaginator() A

↳ Parent: PaginatorTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */
namespace Spiral\Pagination\Traits;

use Interop\Container\ContainerInterface;
use Psr\Http\Message\ServerRequestInterface;
use Spiral\Core\Exceptions\SugarException;
use Spiral\Core\FactoryInterface;
use Spiral\Pagination\Exceptions\PaginationException;
use Spiral\Pagination\Paginator;
use Spiral\Pagination\PaginatorInterface;

/**
 * Provides ability to paginate associated instance. Will work with default Paginator or fetch one
 * from container.
 *
 * Compatible with PaginatorAwareInterface.
 */
trait PaginatorTrait
{
    /**
     * @internal
     * @var PaginatorInterface
     */
    private $paginator = null;

    /**
     * @var int
     */
    protected $limit = 0;

    /**
     * @var int
     */
    protected $offset = 0;

    /**
     * Count elements of an object.
     *
     * @link http://php.net/manual/en/countable.count.php
     * @return int
     */
    abstract public function count();

    /**
     * Set selection limit.
     *
     * @param int $limit
     * @return mixed
     */
    public function limit($limit = 0)
    {
        $this->limit = $limit;

        return $this;
    }

    /**
     * @return int
     */
    public function getLimit()
    {
        return $this->limit;
    }

    /**
     * Set selection offset.
     *
     * @param int $offset
     * @return mixed
     */
    public function offset($offset = 0)
    {
        $this->offset = $offset;

        return $this;
    }

    /**
     * @return int
     */
    public function getOffset()
    {
        return $this->offset;
    }

    /**
     * Manually set paginator instance for specific object.
     *
     * @param PaginatorInterface $paginator
     * @return $this
     */
    public function setPaginator(PaginatorInterface $paginator)
    {
        $this->paginator = $paginator;

        return $this;
    }

    /**
     * Get paginator for the current selection. Paginate method should be already called.
     *
     * @see isPaginated()
     * @see paginate()
     * @return PaginatorInterface|Paginator|null
     */
    public function paginator()
    {
        return $this->paginator;
    }

    /**
     * Get paginator for the current selection. Paginate method should be already called.
     *
     * @see isPaginated()
     * @see paginate()
     * @return PaginatorInterface|Paginator|null
     */
    public function getPaginator()
    {
        return $this->paginator;
    }

    /**
     * Indication that object was paginated.
     *
     * @return bool
     */
    public function isPaginated()
    {
        return !empty($this->paginator);
    }

    /**
     * Paginate current selection using Paginator class.
     *
     * @param int                    $limit         Pagination limit.
     * @param string                 $pageParameter Name of parameter in request query which is
     *                                              used to store the current page number. "page"
     *                                              by default.
     * @param ServerRequestInterface $request       Has to be specified if no global container set.
     * @return $this
     * @throws PaginationException
     */
    public function paginate(
        $limit = Paginator::DEFAULT_LIMIT,
        $pageParameter = Paginator::DEFAULT_PARAMETER,
        ServerRequestInterface $request = null
    ) {
        //Will be used in two places
        $container = $this->container();

        if (empty($request)) {
            if (empty($container) || !$container->has(ServerRequestInterface::class)) {
                throw new SugarException(
                    "Unable to create pagination without specified request."
                );
            }

            //Getting request from container scope
            $request = $container->get(ServerRequestInterface::class);
        }

        if (empty($container) || !$container->has(PaginatorInterface::class)) {
            //Let's use default paginator
            $this->paginator = new Paginator($request, $pageParameter);
        } else {
            //We need constructor
            if ($container instanceof FactoryInterface) {
                $constructor = $container;
            } else {
                $constructor = $container->get(FactoryInterface::class);
            }

            //We can also create paginator using container
            $this->paginator = $constructor->make(PaginatorInterface::class, compact(
                'request', 'pageParameter'
            ));
        }

        $this->paginator->setLimit($limit);

        return $this;
    }

    /**
     * Apply pagination to current object. Will be applied only if internal paginator already
     * constructed.
     *
     * @return $this
     * @throws PaginationException
     */
    protected function applyPagination()
    {
        if (empty($this->paginator)) {
            return $this;
        }

        return $this->paginator->paginate($this);
    }

    /**
     * @return ContainerInterface
     */
    abstract protected function container();
}


1			<?php
2			/**
3			* Spiral Framework.
4			*
5			* @license MIT
6			* @author Anton Titov (Wolfy-J)
7			*/
8			namespace Spiral\Pagination\Traits;
9
10			use Interop\Container\ContainerInterface;
11			use Psr\Http\Message\ServerRequestInterface;
12			use Spiral\Core\Exceptions\SugarException;
13			use Spiral\Core\FactoryInterface;
14			use Spiral\Pagination\Exceptions\PaginationException;
15			use Spiral\Pagination\Paginator;
16			use Spiral\Pagination\PaginatorInterface;
17
18			/**
19			* Provides ability to paginate associated instance. Will work with default Paginator or fetch one
20			* from container.
21			*
22			* Compatible with PaginatorAwareInterface.
23			*/
24			trait PaginatorTrait
25			{
26			/**
27			* @internal
28			* @var PaginatorInterface
29			*/
30			private $paginator = null;
31
32			/**
33			* @var int
34			*/
35			protected $limit = 0;
36
37			/**
38			* @var int
39			*/
40			protected $offset = 0;
41
42			/**
43			* Count elements of an object.
44			*
45			* @link http://php.net/manual/en/countable.count.php
46			* @return int
47			*/
48			abstract public function count();
49
50			/**
51			* Set selection limit.
52			*
53			* @param int $limit
54			* @return mixed
55			*/
56			public function limit($limit = 0)
57			{
58			$this->limit = $limit;
59
60			return $this;
61			}
62
63			/**
64			* @return int
65			*/
66			public function getLimit()
67			{
68			return $this->limit;
69			}
70
71			/**
72			* Set selection offset.
73			*
74			* @param int $offset
75			* @return mixed
76			*/
77			public function offset($offset = 0)
78			{
79			$this->offset = $offset;
80
81			return $this;
82			}
83
84			/**
85			* @return int
86			*/
87			public function getOffset()
88			{
89			return $this->offset;
90			}
91
92			/**
93			* Manually set paginator instance for specific object.
94			*
95			* @param PaginatorInterface $paginator
96			* @return $this
97			*/
98			public function setPaginator(PaginatorInterface $paginator)
99			{
100			$this->paginator = $paginator;
101
102			return $this;
103			}
104
105			/**
106			* Get paginator for the current selection. Paginate method should be already called.
107			*
108			* @see isPaginated()
109			* @see paginate()
110			* @return PaginatorInterface\|Paginator\|null
111			*/
112			public function paginator()
113			{
114			return $this->paginator;
115			}
116
117			/**
118			* Get paginator for the current selection. Paginate method should be already called.
119			*
120			* @see isPaginated()
121			* @see paginate()
122			* @return PaginatorInterface\|Paginator\|null
123			*/
124			public function getPaginator()
125			{
126			return $this->paginator;
127			}
128
129			/**
130			* Indication that object was paginated.
131			*
132			* @return bool
133			*/
134			public function isPaginated()
135			{
136			return !empty($this->paginator);
137			}
138
139			/**
140			* Paginate current selection using Paginator class.
141			*
142			* @param int $limit Pagination limit.
143			* @param string $pageParameter Name of parameter in request query which is
144			* used to store the current page number. "page"
145			* by default.
146			* @param ServerRequestInterface $request Has to be specified if no global container set.
147			* @return $this
148			* @throws PaginationException
149			*/
150			public function paginate(
151			$limit = Paginator::DEFAULT_LIMIT,
152			$pageParameter = Paginator::DEFAULT_PARAMETER,
153			ServerRequestInterface $request = null
154			) {
155			//Will be used in two places
156			$container = $this->container();
157
158			if (empty($request)) {
159			if (empty($container) \|\| !$container->has(ServerRequestInterface::class)) {
160			throw new SugarException(
161			"Unable to create pagination without specified request."
162			);
163			}
164
165			//Getting request from container scope
166			$request = $container->get(ServerRequestInterface::class);
167			}
168
169			if (empty($container) \|\| !$container->has(PaginatorInterface::class)) {
170			//Let's use default paginator
171			$this->paginator = new Paginator($request, $pageParameter);
172			} else {
173			//We need constructor
174			if ($container instanceof FactoryInterface) {
175			$constructor = $container;
176			} else {
177			$constructor = $container->get(FactoryInterface::class);
178			}
179
180			//We can also create paginator using container
181			$this->paginator = $constructor->make(PaginatorInterface::class, compact(
182			'request', 'pageParameter'
183			));
184			}
185
186			$this->paginator->setLimit($limit);
187
188			return $this;
189			}
190
191			/**
192			* Apply pagination to current object. Will be applied only if internal paginator already
193			* constructed.
194			*
195			* @return $this
196			* @throws PaginationException
197			*/
198			protected function applyPagination()
199			{
200			if (empty($this->paginator)) {
201			return $this;
202			}
203
204			return $this->paginator->paginate($this);
205			}
206
207			/**
208			* @return ContainerInterface
209			*/
210			abstract protected function container();
211			}
212

spiral / components

Push — master ( 697d04...680e31 )

PaginatorTrait::getPaginator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like