Component - Code Metrics - Inspection of "change some js" - ScoLib/admin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 75ea25...77dbd7 )

by wen

created 2017-08-01 09:49 UTC

Component B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	257
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

Metric	Value
wmc	43
lcom	1
cbo	6
dl	0
loc	257
rs	8.3157
c	0
b	0
f	0

25 Methods

Rating	Name	Size	Complexity
A	__construct()	16	2
A	setDefaultName()	4	1
A	getModelClassName()	4	1
A	getName()	4	1
A	getTitle()	4	1
A	getModel()	4	1
A	getRepository()	4	1
A	get()	10	1
A	getConfigs()	10	1
A	fireView()	9	2
A	fireCreate()	10	2
A	fireEdit()	10	2
A	bootIfNotBooted()	12	2
A	boot()	4	1
A	isView()	4	2
A	isCreate()	4	2
A	isEdit()	4	2
A	isDelete()	4	1
A	isDestroy()	4	2
A	isRestore()	4	2
A	isRestorableModel()	4	1
B	registerObserver()	15	5
A	registerPermission()	4	1
A	can()	7	3
A	getPermissions()	13	3

How to fix Complexity

<?php

namespace Sco\Admin\Component;

use Illuminate\Foundation\Application;
use Sco\Admin\Component\Concerns\HasEvents;
use Sco\Admin\Component\Concerns\HasNavigation;
use Sco\Admin\Contracts\ComponentInterface;
use Sco\Admin\Contracts\RepositoryInterface;
use Sco\Admin\Exceptions\BadMethodCallException;

abstract class Component implements ComponentInterface
{
    use HasEvents,
        HasNavigation;

    /**
     * @var
     */
    protected $name;

    /**
     * @var \Illuminate\Foundation\Application
     */
    protected $app;

    protected $title;

    /**
     * @var mixed|\Sco\Admin\Contracts\RepositoryInterface
     */
    protected $repository;

    /**
     * @var \Illuminate\Database\Eloquent\Model
     */
    protected $model;

    protected static $booted = [];

    /**
     * @var \Illuminate\Contracts\Events\Dispatcher
     */
    protected static $dispatcher;

    /**
     * @var string
     */
    protected $permissionObserver;

    protected $permissions;

    protected $permissionMethods = [
        'view', 'create', 'edit',
        'delete', 'destroy', 'restore',
    ];

    public function __construct(Application $app, $modelClass)
    {
        $this->app = $app;

        $this->repository = $this->app->make(RepositoryInterface::class);
        $this->repository->setClass($modelClass);

        $this->model = $this->repository->getModel();
        if (!$this->name) {
            $this->setDefaultName();
        }

        $this->registerObserver($this->permissionObserver);

        $this->bootIfNotBooted();
    }

    protected function setDefaultName()
    {
        $this->name = $this->getModelClassName();
    }

    protected function getModelClassName()
    {
        return snake_case(str_plural(class_basename(get_class($this->getModel()))));
    }

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

    public function getTitle()
    {
        return $this->title;
    }

    public function getModel()
    {
        return $this->model;
    }

    public function getRepository()
    {
        return $this->repository;
    }

    public function get()
    {
        $view = $this->fireView();

        $this->getRepository();
class User
{
    private $email;

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

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

        $view->setRepository($this->getRepository());

        return $view->get();
    }


    /**
     * {@inheritdoc}
     */
    public function getConfigs()
    {
        return collect([
            'primaryKey'  => $this->getModel()->getKeyName(),
            'title'       => $this->getTitle(),
            'permissions' => $this->getPermissions(),
            'view'        => $this->fireView(),
            //'elements'    => $this->getElements()->values(),

        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function fireView()
    {
        if (!method_exists($this, 'callView')) {
            throw new BadMethodCallException('Not Found Method "callView"');
        }

        $view = $this->app->call([$this, 'callView']);
        return $view;
    }

    /**
     * {@inheritdoc}
     */
    public function fireCreate()
    {
        if (!method_exists($this, 'callCreate')) {
            return;
        }

        $form = $this->app->call([$this, 'callCreate']);

        return $form;
    }

    /**
     * {@inheritdoc}
     */
    public function fireEdit($id)
    {
        if (!method_exists($this, 'callEdit')) {
            return;
        }

        $form = $this->app->call([$this, 'callEdit'], ['id' => $id]);

        return $form;
    }


    protected function bootIfNotBooted()
    {
        if (!isset(static::$booted[static::class])) {
            static::$booted[static::class] = true;

            $this->fireEvent('booting', false);

            $this->boot();
class User
{
    private $email;

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

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

            $this->fireEvent('booted', false);
        }
    }

    public function boot()
    {
        return true;
    }

    public function isView()
    {
        return method_exists($this, 'callView') && $this->can('view');
    }

    public function isCreate()
    {
        return method_exists($this, 'callCreate') && $this->can('create');
    }

    public function isEdit()
    {
        return method_exists($this, 'callEdit') && $this->can('edit');
    }

    public function isDelete()
    {
        return $this->can('delete');
    }

    public function isDestroy()
    {
        return $this->isRestorableModel() && $this->can('destroy');
    }

    public function isRestore()
    {
        return $this->isRestorableModel() && $this->can('restore');
    }

    protected function isRestorableModel()
    {
        return $this->getRepository()->isRestorable();
    }

    public function registerObserver($class = null)
    {
        if (!$class) {
            return;
        }

        $className = is_string($class) ? $class : get_class($class);

        foreach ($this->permissionMethods as $method) {
            if (method_exists($class, $method)) {
                $this->registerPermission($method,
                    [$this->app->make($className), $method]);
            }
        }
    }

    public function registerPermission($permission, $callback)
    {
        $this->permissions[$permission] = $callback;
    }

    public function can($permission)
    {
        if (is_callable($this->permissions[$permission])) {
            return call_user_func_array($this->permissions[$permission], [$this]);
        }
        return $this->permissions[$permission] ? true : false;
    }

    public function getPermissions()
    {
        $data = collect();
        foreach ($this->permissionMethods as $perm) {
            $method = 'is' . ucfirst($perm);
            if (!method_exists($this, $method)) {
                $method = 'can';
            }

            $data->put($perm, $this->{$method}($perm));
        }
        return $data;
    }
}


1			<?php
2
3			namespace Sco\Admin\Component;
4
5			use Illuminate\Foundation\Application;
6			use Sco\Admin\Component\Concerns\HasEvents;
7			use Sco\Admin\Component\Concerns\HasNavigation;
8			use Sco\Admin\Contracts\ComponentInterface;
9			use Sco\Admin\Contracts\RepositoryInterface;
10			use Sco\Admin\Exceptions\BadMethodCallException;
11
12			abstract class Component implements ComponentInterface
13			{
14			use HasEvents,
15			HasNavigation;
16
17			/**
18			* @var
19			*/
20			protected $name;
21
22			/**
23			* @var \Illuminate\Foundation\Application
24			*/
25			protected $app;
26
27			protected $title;
28
29			/**
30			* @var mixed\|\Sco\Admin\Contracts\RepositoryInterface
31			*/
32			protected $repository;
33
34			/**
35			* @var \Illuminate\Database\Eloquent\Model
36			*/
37			protected $model;
38
39			protected static $booted = [];
40
41			/**
42			* @var \Illuminate\Contracts\Events\Dispatcher
43			*/
44			protected static $dispatcher;
45
46			/**
47			* @var string
48			*/
49			protected $permissionObserver;
50
51			protected $permissions;
52
53			protected $permissionMethods = [
54			'view', 'create', 'edit',
55			'delete', 'destroy', 'restore',
56			];
57
58			public function __construct(Application $app, $modelClass)
59			{
60			$this->app = $app;
61
62			$this->repository = $this->app->make(RepositoryInterface::class);
63			$this->repository->setClass($modelClass);
64
65			$this->model = $this->repository->getModel();
66			if (!$this->name) {
67			$this->setDefaultName();
68			}
69
70			$this->registerObserver($this->permissionObserver);
71
72			$this->bootIfNotBooted();
73			}
74
75			protected function setDefaultName()
76			{
77			$this->name = $this->getModelClassName();
78			}
79
80			protected function getModelClassName()
81			{
82			return snake_case(str_plural(class_basename(get_class($this->getModel()))));
83			}
84
85			public function getName()
86			{
87			return $this->name;
88			}
89
90			public function getTitle()
91			{
92			return $this->title;
93			}
94
95			public function getModel()
96			{
97			return $this->model;
98			}
99
100			public function getRepository()
101			{
102			return $this->repository;
103			}
104
105			public function get()
106			{
107			$view = $this->fireView();
108
109			$this->getRepository();
			0 ignored issues – show Unused Code introduced 2017-07-24 08:59 UTC by Report Bug Copy Issue Report The call to the method `Sco\Admin\Component\Component::getRepository()` seems un-needed as the method has no side-effects. PHP Analyzer performs a side-effects analysis of your code. A side-effect is basically anything that might be visible after the scope of the method is left. Let’s take a look at an example: class User { private $email; public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } } If we look at the `getEmail()` method, we can see that it has no side-effect. Whether you call this method or not, no future calls to other methods are affected by this. As such code as the following is useless: $user = new User(); $user->getEmail(); // This line could safely be removed as it has no effect. On the hand, if we look at the `setEmail()`, this method _has_ side-effects. In the following case, we could not remove the method call: $user = new User(); $user->setEmail('email@domain'); // This line has a side-effect (it changes an // instance variable). Loading history...
110
111			$view->setRepository($this->getRepository());
112
113			return $view->get();
114			}
115
116
117			/**
118			* {@inheritdoc}
119			*/
120			public function getConfigs()
121			{
122			return collect([
123			'primaryKey' => $this->getModel()->getKeyName(),
124			'title' => $this->getTitle(),
125			'permissions' => $this->getPermissions(),
126			'view' => $this->fireView(),
127			//'elements' => $this->getElements()->values(),
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-07-18 09:48 UTC by Report Bug Copy Issue Report `72%` 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...
128			]);
129			}
130
131			/**
132			* {@inheritdoc}
133			*/
134			public function fireView()
135			{
136			if (!method_exists($this, 'callView')) {
137			throw new BadMethodCallException('Not Found Method "callView"');
138			}
139
140			$view = $this->app->call([$this, 'callView']);
141			return $view;
142			}
143
144			/**
145			* {@inheritdoc}
146			*/
147			public function fireCreate()
148			{
149			if (!method_exists($this, 'callCreate')) {
150			return;
151			}
152
153			$form = $this->app->call([$this, 'callCreate']);
154
155			return $form;
156			}
157
158			/**
159			* {@inheritdoc}
160			*/
161			public function fireEdit($id)
162			{
163			if (!method_exists($this, 'callEdit')) {
164			return;
165			}
166
167			$form = $this->app->call([$this, 'callEdit'], ['id' => $id]);
168
169			return $form;
170			}
171
172
173			protected function bootIfNotBooted()
174			{
175			if (!isset(static::$booted[static::class])) {
176			static::$booted[static::class] = true;
177
178			$this->fireEvent('booting', false);
179
180			$this->boot();
			0 ignored issues – show Unused Code introduced 2017-07-18 12:53 UTC by Report Bug Copy Issue Report The call to the method `Sco\Admin\Component\Component::boot()` seems un-needed as the method has no side-effects. PHP Analyzer performs a side-effects analysis of your code. A side-effect is basically anything that might be visible after the scope of the method is left. Let’s take a look at an example: class User { private $email; public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } } If we look at the `getEmail()` method, we can see that it has no side-effect. Whether you call this method or not, no future calls to other methods are affected by this. As such code as the following is useless: $user = new User(); $user->getEmail(); // This line could safely be removed as it has no effect. On the hand, if we look at the `setEmail()`, this method _has_ side-effects. In the following case, we could not remove the method call: $user = new User(); $user->setEmail('email@domain'); // This line has a side-effect (it changes an // instance variable). Loading history...
181
182			$this->fireEvent('booted', false);
183			}
184			}
185
186			public function boot()
187			{
188			return true;
189			}
190
191			public function isView()
192			{
193			return method_exists($this, 'callView') && $this->can('view');
194			}
195
196			public function isCreate()
197			{
198			return method_exists($this, 'callCreate') && $this->can('create');
199			}
200
201			public function isEdit()
202			{
203			return method_exists($this, 'callEdit') && $this->can('edit');
204			}
205
206			public function isDelete()
207			{
208			return $this->can('delete');
209			}
210
211			public function isDestroy()
212			{
213			return $this->isRestorableModel() && $this->can('destroy');
214			}
215
216			public function isRestore()
217			{
218			return $this->isRestorableModel() && $this->can('restore');
219			}
220
221			protected function isRestorableModel()
222			{
223			return $this->getRepository()->isRestorable();
224			}
225
226			public function registerObserver($class = null)
227			{
228			if (!$class) {
229			return;
230			}
231
232			$className = is_string($class) ? $class : get_class($class);
233
234			foreach ($this->permissionMethods as $method) {
235			if (method_exists($class, $method)) {
236			$this->registerPermission($method,
237			[$this->app->make($className), $method]);
238			}
239			}
240			}
241
242			public function registerPermission($permission, $callback)
243			{
244			$this->permissions[$permission] = $callback;
245			}
246
247			public function can($permission)
248			{
249			if (is_callable($this->permissions[$permission])) {
250			return call_user_func_array($this->permissions[$permission], [$this]);
251			}
252			return $this->permissions[$permission] ? true : false;
253			}
254
255			public function getPermissions()
256			{
257			$data = collect();
258			foreach ($this->permissionMethods as $perm) {
259			$method = 'is' . ucfirst($perm);
260			if (!method_exists($this, $method)) {
261			$method = 'can';
262			}
263
264			$data->put($perm, $this->{$method}($perm));
265			}
266			return $data;
267			}
268			}
269

ScoLib / admin

Push — master ( 75ea25...77dbd7 )

Component B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

25 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like