PageRepository - Code Metrics - Inspection of "Update readme.md" - webshelf/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 85cdf0...87050d )

by Mark

created 2018-01-29 11:24 UTC

PageRepository A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

Metric	Value
dl	0
loc	105
c	0
b	0
f	0
rs	10
wmc	12
lcom	1
cbo	1

12 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	restoreTrashedPlugin()	4	1
A	makeList()	4	1
A	listAllPagesWithoutMenusAndEditable()	4	1
A	listPagesWithoutMenus()	4	1
A	allPagesWithoutMenusAndEditable()	4	1
A	whereName()	4	1
A	whereRoute()	4	1
A	wherePlugin()	4	1
A	whereSitemap()	4	1
A	enabled()	4	1
A	frontendPageCollection()	7	1

<?php
/**
 * Created by PhpStorm.
 * User: Mark
 * Date: 04/03/2016
 * Time: 23:07.
 */

namespace App\Classes\Repositories;

use App\Model\Page;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Builder;

/**
 * Class PageRepository.
 *
 * @method Page withTrashed
 */
class PageRepository extends BaseRepository
{
    /**
     * @var Page|Builder|Collection
     */
    protected $model;

    /**
     * PageRepository constructor.
     *
     * @param Page $model
     */
    public function __construct(Page $model)
    {
        $this->model = $model;
    }

    /**
     * @param $plugin_name
     * @return mixed
     */
    public function restoreTrashedPlugin($plugin_name)
    {
        return $this->model->withTrashed()->where('plugin', $plugin_name)->restore();
    }

    /**
     * @return mixed
     */
    public function makeList() : array
    {
        return $this->model->pluck('seo_title', 'id')->toArray();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * @deprecated
     */
    public function listAllPagesWithoutMenusAndEditable()

    {
        return $this->model->where('editable', true)->doesntHave('menu')->pluck('seo_title', 'id');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function listPagesWithoutMenus()

    {
        return $this->model->doesntHave('menu')->get();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function allPagesWithoutMenusAndEditable() : Collection
    {
        return $this->model->where('editable', true)->doesntHave('menus')->get();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Get the page based on its name.
     *
     * @param $string
     * @return Page|array|\stdClass
     */
    public function whereName($string) : Page
    {
        return $this->model->where('slug', $string)->first();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * @param $string
     * @return Page
     */
    public function whereRoute($string) : Page
    {
        return $this->model->where('route', $string)->first();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * @param $string
     * @return Page
     */
    public function wherePlugin($string) : Page
    {
        return $this->model->where('plugin', $string)->first();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Sitemap enabled pages.
     */
    public function whereSitemap() : Collection
    {
        return $this->model->where('sitemap', true)->where('enabled', true)->get();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Return all pages that are enabled.
     */
    public function enabled() : Collection
    {
        return $this->model->where('enabled', true)->get();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function frontendPageCollection()

    {
        return $this->model->with(['menu'])->get();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
//        return $this->with(['menu' => function ($query) {

//            $query->with('parent');
//        }])->get();
    }
}


1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: Mark
5			* Date: 04/03/2016
6			* Time: 23:07.
7			*/
8
9			namespace App\Classes\Repositories;
10
11			use App\Model\Page;
12			use Illuminate\Support\Collection;
13			use Illuminate\Database\Eloquent\Builder;
14
15			/**
16			* Class PageRepository.
17			*
18			* @method Page withTrashed
19			*/
20			class PageRepository extends BaseRepository
21			{
22			/**
23			* @var Page\|Builder\|Collection
24			*/
25			protected $model;
26
27			/**
28			* PageRepository constructor.
29			*
30			* @param Page $model
31			*/
32			public function __construct(Page $model)
33			{
34			$this->model = $model;
35			}
36
37			/**
38			* @param $plugin_name
39			* @return mixed
40			*/
41			public function restoreTrashedPlugin($plugin_name)
42			{
43			return $this->model->withTrashed()->where('plugin', $plugin_name)->restore();
44			}
45
46			/**
47			* @return mixed
48			*/
49			public function makeList() : array
50			{
51			return $this->model->pluck('seo_title', 'id')->toArray();
			0 ignored issues – show Bug introduced 2018-01-05 17:28 UTC by Report Bug Copy Issue Report The method `pluck` does only exist in `Illuminate\Database\Eloq...nate\Support\Collection`, but not in `App\Model\Page`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
52			}
53
54			/**
55			* @deprecated
56			*/
57			public function listAllPagesWithoutMenusAndEditable()
			0 ignored issues – show Documentation introduced 2017-09-03 15:41 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
58			{
59			return $this->model->where('editable', true)->doesntHave('menu')->pluck('seo_title', 'id');
			0 ignored issues – show Bug introduced 2018-01-05 17:28 UTC by Report Bug Copy Issue Report The method `where` does only exist in `Illuminate\Database\Eloq...nate\Support\Collection`, but not in `App\Model\Page`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
60			}
61
62			public function listPagesWithoutMenus()
			0 ignored issues – show Documentation introduced 2017-12-23 22:09 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
63			{
64			return $this->model->doesntHave('menu')->get();
			0 ignored issues – show Bug introduced 2018-01-05 17:28 UTC by Report Bug Copy Issue Report The method `doesntHave` does only exist in `Illuminate\Database\Eloquent\Builder`, but not in `App\Model\Page and Illuminate\Support\Collection`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
65			}
66
67			public function allPagesWithoutMenusAndEditable() : Collection
68			{
69			return $this->model->where('editable', true)->doesntHave('menus')->get();
			0 ignored issues – show Bug introduced 2018-01-05 17:28 UTC by Report Bug Copy Issue Report The method `where` does only exist in `Illuminate\Database\Eloq...nate\Support\Collection`, but not in `App\Model\Page`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
70			}
71
72			/**
73			* Get the page based on its name.
74			*
75			* @param $string
76			* @return Page\|array\|\stdClass
77			*/
78			public function whereName($string) : Page
79			{
80			return $this->model->where('slug', $string)->first();
			0 ignored issues – show Bug introduced 2018-01-05 17:28 UTC by Report Bug Copy Issue Report The method `where` does only exist in `Illuminate\Database\Eloq...nate\Support\Collection`, but not in `App\Model\Page`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
81			}
82
83			/**
84			* @param $string
85			* @return Page
86			*/
87			public function whereRoute($string) : Page
88			{
89			return $this->model->where('route', $string)->first();
			0 ignored issues – show Bug introduced 2018-01-20 13:27 UTC by Report Bug Copy Issue Report The method `where` does only exist in `Illuminate\Database\Eloq...nate\Support\Collection`, but not in `App\Model\Page`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
90			}
91
92			/**
93			* @param $string
94			* @return Page
95			*/
96			public function wherePlugin($string) : Page
97			{
98			return $this->model->where('plugin', $string)->first();
			0 ignored issues – show Bug introduced 2018-01-23 19:59 UTC by Report Bug Copy Issue Report The method `where` does only exist in `Illuminate\Database\Eloq...nate\Support\Collection`, but not in `App\Model\Page`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
99			}
100
101			/**
102			* Sitemap enabled pages.
103			*/
104			public function whereSitemap() : Collection
105			{
106			return $this->model->where('sitemap', true)->where('enabled', true)->get();
			0 ignored issues – show Bug introduced 2018-01-05 17:28 UTC by Report Bug Copy Issue Report The method `where` does only exist in `Illuminate\Database\Eloq...nate\Support\Collection`, but not in `App\Model\Page`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
107			}
108
109			/**
110			* Return all pages that are enabled.
111			*/
112			public function enabled() : Collection
113			{
114			return $this->model->where('enabled', true)->get();
			0 ignored issues – show Bug introduced 2018-01-05 17:28 UTC by Report Bug Copy Issue Report The method `where` does only exist in `Illuminate\Database\Eloq...nate\Support\Collection`, but not in `App\Model\Page`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
115			}
116
117			public function frontendPageCollection()
			0 ignored issues – show Documentation introduced 2017-12-23 22:09 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
118			{
119			return $this->model->with(['menu'])->get();
			0 ignored issues – show Bug introduced 2018-01-05 17:28 UTC by Report Bug Copy Issue Report The method `with` does only exist in `App\Model\Page and Illum...tabase\Eloquent\Builder`, but not in `Illuminate\Support\Collection`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
120			// return $this->with(['menu' => function ($query) {
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-12-23 22:09 UTC by Report Bug Copy Issue Report `64%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
121			// $query->with('parent');
122			// }])->get();
123			}
124			}
125

webshelf / framework

Scrutinizer GitHub App not installed

Push — master ( 85cdf0...87050d )

PageRepository A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

12 Methods

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like