Page::hasNext() - Code Metrics - nilportugues/repository - Measure and Improve Code Quality continuously with Scrutinizer

Page::hasNext() A
last analyzed 2016-01-25 17:23 UTC

↳ Parent: Page

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

/**
 * Author: Nil Portugués Calderó <[email protected]>
 * Date: 6/15/15
 * Time: 11:31 PM.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace NilPortugues\Foundation\Domain\Model\Repository;

use NilPortugues\Foundation\Domain\Model\Repository\Collections\ImmutableTypedCollection;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Fields as FieldsInterface;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Filter as FilterInterface;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Page as PageInterface;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Pageable as PageableInterface;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Sort as SortInterface;

class Page implements PageInterface
{
    /**
     * @var ImmutableTypedCollection
     */
    protected $elements;
    /**
     * @var int
     */
    protected $totalPages;
    /**
     * @var int
     */
    protected $totalElements;
    /**
     * @var int
     */
    protected $pageNumber;
    /**
     * @var SortInterface
     */
    protected $sort;
    /**
     * @var FilterInterface
     */
    protected $filter;

    /**
     * @var Fields
     */
    protected $fields;

    /**
     * Page constructor.
     *
     * @param array           $elements
     * @param                 $totalElements
     * @param                 $pageNumber
     * @param                 $totalPages
     * @param SortInterface   $sort
     * @param FilterInterface $filter
     * @param FieldsInterface $fields
     */
    public function __construct(
        array $elements,
        $totalElements,
        $pageNumber,
        $totalPages,
        SortInterface $sort = null,
        FilterInterface $filter = null,
        FieldsInterface $fields = null
    ) {
        $this->elements = ImmutableTypedCollection::fromArray($elements);
        $this->totalElements = (int) $totalElements;
        $this->pageNumber = (int) $pageNumber;
        $this->totalPages = (int) $totalPages;
        $this->sort = ($sort) ? $sort : new Sort();
        $this->filter = ($filter) ? $filter : new Filter();
        $this->fields = ($fields) ? $fields : new Fields();
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
    }

    /**
     * Returns the page content as an array.
     *
     * @return ImmutableTypedCollection
     */
    public function content()
    {
        return $this->elements;
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());
}
    }

    /**
     * Returns if there is a previous Page.
     *
     * @return bool
     */
    public function hasPrevious()
    {
        return $this->pageNumber > 1;
    }

    /**
     * Returns whether the current Page is the first one.
     *
     * @return bool
     */
    public function isFirst()
    {
        return 1 === $this->pageNumber;
    }

    /**
     * Returns whether the current Page is the last one.
     *
     * @return bool
     */
    public function isLast()
    {
        return false === $this->hasNext();
    }

    /**
     * Returns if there is a next Page.
     *
     * @return bool
     */
    public function hasNext()
    {
        return $this->pageSize() * $this->pageNumber() < $this->totalPages();
    }

    /**
     * Returns the size of the Page.
     *
     * @return int
     */
    public function pageSize()
    {
        return count($this->elements);
    }

    /**
     * Returns the number of the current Page.
     *
     * @return int
     */
    public function pageNumber()
    {
        return $this->pageNumber;
    }

    /**
     * Returns the number of total pages.
     *
     * @return int
     */
    public function totalPages()
    {
        return $this->totalPages;
    }

    /**
     * Returns the Pageable to request the next Page.
     *
     * @return PageableInterface
     */
    public function nextPageable()
    {
        return new Pageable(
            $this->pageNumber() + 1,
            $this->pageSize(),
            $this->sortings(),
            $this->filters(),
            $this->fields()
        );
    }

    /**
     * Returns the sorting parameters for the Page.
     *
     * @return SortInterface
     */
    public function sortings()
    {
        return $this->sort;
    }

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

    /**
     * @return FieldsInterface
     */
    public function fields()
    {
        return $this->fields;
    }

    /**
     * Returns the Pageable to request the previous Page.
     *
     * @return PageableInterface
     */
    public function previousPageable()
    {
        $pageable = new Pageable(
            $this->pageNumber(),
            $this->pageSize(),
            $this->sortings(),
            $this->filters(),
            $this->fields()
        );

        return $pageable->previousOrFirst();
    }

    /**
     * Returns the total amount of elements.
     *
     * @return int
     */
    public function totalElements()
    {
        return $this->totalElements;
    }

    /**
     * Returns a new Page with the content of the current one mapped by the $converter callable.
     *
     * @param callable $converter
     *
     * @return PageInterface
     */
    public function map(callable $converter)
    {
        $collection = [];
        foreach ($this->elements as $key => $element) {
            $collection[$key] = $converter($element);
        }

        return new self(
            $collection,
            $this->totalElements,
            $this->pageNumber,
            $this->totalPages,
            $this->sort,
            $this->filter,
            $this->fields
        );
    }
}


1			<?php
2
3			/**
4			* Author: Nil Portugués Calderó <[email protected]>
5			* Date: 6/15/15
6			* Time: 11:31 PM.
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11			namespace NilPortugues\Foundation\Domain\Model\Repository;
12
13			use NilPortugues\Foundation\Domain\Model\Repository\Collections\ImmutableTypedCollection;
14			use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Fields as FieldsInterface;
15			use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Filter as FilterInterface;
16			use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Page as PageInterface;
17			use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Pageable as PageableInterface;
18			use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Sort as SortInterface;
19
20			class Page implements PageInterface
21			{
22			/**
23			* @var ImmutableTypedCollection
24			*/
25			protected $elements;
26			/**
27			* @var int
28			*/
29			protected $totalPages;
30			/**
31			* @var int
32			*/
33			protected $totalElements;
34			/**
35			* @var int
36			*/
37			protected $pageNumber;
38			/**
39			* @var SortInterface
40			*/
41			protected $sort;
42			/**
43			* @var FilterInterface
44			*/
45			protected $filter;
46
47			/**
48			* @var Fields
49			*/
50			protected $fields;
51
52			/**
53			* Page constructor.
54			*
55			* @param array $elements
56			* @param $totalElements
57			* @param $pageNumber
58			* @param $totalPages
59			* @param SortInterface $sort
60			* @param FilterInterface $filter
61			* @param FieldsInterface $fields
62			*/
63			public function __construct(
64			array $elements,
65			$totalElements,
66			$pageNumber,
67			$totalPages,
68			SortInterface $sort = null,
69			FilterInterface $filter = null,
70			FieldsInterface $fields = null
71			) {
72			$this->elements = ImmutableTypedCollection::fromArray($elements);
73			$this->totalElements = (int) $totalElements;
74			$this->pageNumber = (int) $pageNumber;
75			$this->totalPages = (int) $totalPages;
76			$this->sort = ($sort) ? $sort : new Sort();
77			$this->filter = ($filter) ? $filter : new Filter();
78			$this->fields = ($fields) ? $fields : new Fields();
			0 ignored issues – show Documentation Bug introduced 2016-01-21 14:50 UTC by Report Bug Copy Issue Report `$fields ? $fields : new ...del\Repository\Fields()` is of type `object<NilPortugues\Foun...itory\Contracts\Fields>`, but the property `$fields` was declared to be of type `object<NilPortugues\Foun...odel\Repository\Fields>`. Are you sure that you always receive this specific sub-class here, or does it make sense to add an `instanceof` check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a given class or a super-class is assigned to a property that is type hinted more strictly. Either this assignment is in error or an instanceof check should be added for that assignment. class Alien {} class Dalek extends Alien {} class Plot { /** @var Dalek */ public $villain; } $alien = new Alien(); $plot = new Plot(); if ($alien instanceof Dalek) { $plot->villain = $alien; } Loading history...
79			}
80
81			/**
82			* Returns the page content as an array.
83			*
84			* @return ImmutableTypedCollection
85			*/
86			public function content()
87			{
88			return $this->elements;
			0 ignored issues – show Bug Best Practice introduced 2016-01-25 17:23 UTC by Report Bug Copy Issue Report The return type of `return $this->elements;` (`NilPortugues\Foundation\...mmutableTypedCollection`) is incompatible with the return type declared by the interface `NilPortugues\Foundation\...Contracts\Page::content` of type `array`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: 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()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
89			}
90
91			/**
92			* Returns if there is a previous Page.
93			*
94			* @return bool
95			*/
96			public function hasPrevious()
97			{
98			return $this->pageNumber > 1;
99			}
100
101			/**
102			* Returns whether the current Page is the first one.
103			*
104			* @return bool
105			*/
106			public function isFirst()
107			{
108			return 1 === $this->pageNumber;
109			}
110
111			/**
112			* Returns whether the current Page is the last one.
113			*
114			* @return bool
115			*/
116			public function isLast()
117			{
118			return false === $this->hasNext();
119			}
120
121			/**
122			* Returns if there is a next Page.
123			*
124			* @return bool
125			*/
126			public function hasNext()
127			{
128			return $this->pageSize() * $this->pageNumber() < $this->totalPages();
129			}
130
131			/**
132			* Returns the size of the Page.
133			*
134			* @return int
135			*/
136			public function pageSize()
137			{
138			return count($this->elements);
139			}
140
141			/**
142			* Returns the number of the current Page.
143			*
144			* @return int
145			*/
146			public function pageNumber()
147			{
148			return $this->pageNumber;
149			}
150
151			/**
152			* Returns the number of total pages.
153			*
154			* @return int
155			*/
156			public function totalPages()
157			{
158			return $this->totalPages;
159			}
160
161			/**
162			* Returns the Pageable to request the next Page.
163			*
164			* @return PageableInterface
165			*/
166			public function nextPageable()
167			{
168			return new Pageable(
169			$this->pageNumber() + 1,
170			$this->pageSize(),
171			$this->sortings(),
172			$this->filters(),
173			$this->fields()
174			);
175			}
176
177			/**
178			* Returns the sorting parameters for the Page.
179			*
180			* @return SortInterface
181			*/
182			public function sortings()
183			{
184			return $this->sort;
185			}
186
187			/**
188			* @return FilterInterface
189			*/
190			public function filters()
191			{
192			return $this->filter;
193			}
194
195			/**
196			* @return FieldsInterface
197			*/
198			public function fields()
199			{
200			return $this->fields;
201			}
202
203			/**
204			* Returns the Pageable to request the previous Page.
205			*
206			* @return PageableInterface
207			*/
208			public function previousPageable()
209			{
210			$pageable = new Pageable(
211			$this->pageNumber(),
212			$this->pageSize(),
213			$this->sortings(),
214			$this->filters(),
215			$this->fields()
216			);
217
218			return $pageable->previousOrFirst();
219			}
220
221			/**
222			* Returns the total amount of elements.
223			*
224			* @return int
225			*/
226			public function totalElements()
227			{
228			return $this->totalElements;
229			}
230
231			/**
232			* Returns a new Page with the content of the current one mapped by the $converter callable.
233			*
234			* @param callable $converter
235			*
236			* @return PageInterface
237			*/
238			public function map(callable $converter)
239			{
240			$collection = [];
241			foreach ($this->elements as $key => $element) {
242			$collection[$key] = $converter($element);
243			}
244
245			return new self(
246			$collection,
247			$this->totalElements,
248			$this->pageNumber,
249			$this->totalPages,
250			$this->sort,
251			$this->filter,
252			$this->fields
253			);
254			}
255			}
256

nilportugues / repository

Page::hasNext() A last analyzed 2016-01-25 17:23 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Page::hasNext() A
last analyzed 2016-01-25 17:23 UTC