AbstractRestfulController - Code Metrics - TomHart/laravel-restful-controller - Measure and Improve Code Quality continuously with Scrutinizer

AbstractRestfulController B
last analyzed 2020-09-02 20:23 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	359
Duplicated Lines	6.69 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

Metric	Value
wmc	43
lcom	1
cbo	12
dl	24
loc	359
rs	8.96
c	0
b	0
f	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	index()	0	17	2
A	createModelQueryBuilder()	0	4	1
A	newModelInstance()	0	6	1
	getModelClass()	0	1	?
A	filterValue()	0	4	1
B	return()	0	37	8
B	redirectToShowRoute()	0	46	5
A	store()	12	12	2
A	saveModel()	0	4	1
A	findModel()	0	12	2
A	preloadRelationships()	0	16	4
A	show()	0	8	1
B	iterateThroughChildren()	0	41	9
A	update()	12	12	2
A	destroy()	0	8	1
A	options()	0	14	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AbstractRestfulController often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AbstractRestfulController, and based on these observations, apply Extract Interface, too.

<?php

namespace TomHart\Restful;

use BadMethodCallException;
use Exception;
use Illuminate\Contracts\Pagination\LengthAwarePaginator;
use Illuminate\Contracts\Routing\ResponseFactory;
use Illuminate\Contracts\View\Factory;
use Illuminate\Database\Eloquent\Builder;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOneOrMany;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphOneOrMany;
use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Routing\Controller as BaseController;
use Illuminate\Routing\Redirector;
use Illuminate\Routing\Route;
use Illuminate\Support\Str;
use Illuminate\View\View;
use InvalidArgumentException;
use Symfony\Component\HttpFoundation\Response as SymResponse;
use TomHart\Restful\Concerns\HasLinks;

abstract class AbstractRestfulController extends BaseController
{
    use AuthorizesRequests;
    use ValidatesRequests;

    /**
     * The views to render.
     * @var string[]
     */
    protected $views = [];

    /**
     * Return a list of matching models.
     * @param Request $request
     * @return JsonResponse|RedirectResponse|ResponseFactory|Response|Redirector
     */
    public function index(Request $request)
    {
        $builder = $this->createModelQueryBuilder();

        $input = collect($request->input())->except(config('restful.query_string_keys.page'))->toArray();
        foreach ($input as $column => $value) {
            $this->filterValue($builder, $column, $value);
        }

        $data = $builder->paginate(
            $request->input('limit', null),
            ['*'],
            config('restful.query_string_keys.page')
        );

        return $this->return($request, $data, 'index');
    }

    /**
     * Generate a new query builder for the model.
     * @return Builder
     */
    protected function createModelQueryBuilder(): Builder
    {
        return $this->newModelInstance()->newQuery();
    }

    /**
     * Creates a new model instance.
     * @return Model
     */
    protected function newModelInstance(): Model
    {
        $classFQDN = $this->getModelClass();

        return app($classFQDN);
    }

    /**
     * What Model class to search for entities.
     * @return string
     */
    abstract protected function getModelClass(): string;

    /**
     * Apply causes to the builder.
     * @param Builder $builder
     * @param string $column
     * @param mixed $value
     */
    protected function filterValue(Builder $builder, string $column, $value): void
    {
        $builder->where($column, $value);
    }

    /**
     * Build and return a response.
     * @param Request $request
     * @param mixed $data
     * @param string $method
     * @return JsonResponse|ResponseFactory|Response|RedirectResponse|Redirector
     */
    protected function return(Request $request, $data, string $method)
    {
        $status = SymResponse::HTTP_OK;
        switch ($method) {
            case 'store':
                $status = SymResponse::HTTP_CREATED;
                break;
        }

        if ($request->wantsJson()) {
            return app(ResponseFactory::class)->json($data, $status);
        }

        if (isset($this->views[$method]) && app(Factory::class)->exists($this->views[$method])) {
            /** @var View $view */
            $view = view(
                $this->views[$method],
                [
                    'data' => $data
                ]
            );

            return response($view, $status);
        }

        switch ($method) {
            case 'store':
            case 'update':
                // If it's store/update, and the user isn't asking for JSON, we want to
                // try and redirect them to the related show record page.
                if (($redirect = $this->redirectToShowRoute($request, $data))) {
                    return $redirect;
                }
        }

        return app(ResponseFactory::class)->json($data, $status);
    }

    /**
     * Redirects to the show route for the model if one exists.
     * @param Request $request
     * @param mixed $data
     * @return RedirectResponse|Redirector|null
     */
    protected function redirectToShowRoute(Request $request, $data)
    {
        if ($data instanceof HasLinks) {
            $route = $data->getRouteName() . '.show';
            $key = $data->getRouteKey();

            return redirect(
                route(
                    $route,
                    [
                        $key => $data->id
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    ]
                )
            );
        }

        /** @var Route|null $route */
        $route = $request->route();
        if (!$route) {
            return null;
        }

        $name = $route->getName();
        if (!$name) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return null;
        }

        $exploded = explode('.', $name);
        array_pop($exploded);
        $topLevel = array_pop($exploded);

        if (!$topLevel) {
            return null;
        }

        $key = Str::singular(str_replace('-', '_', $topLevel));

        return redirect(
            route(
                "$topLevel.show",
                [
                    $key => $data->id
                ]
            )
        );
    }

    /**
     * Handles creating a model. The C of CRUD
     * @param Request $request
     * @return JsonResponse|RedirectResponse|ResponseFactory|Response|Redirector
     */
    public function store(Request $request)

    {
        $model = $this->newModelInstance();

        foreach ((array)$request->input() as $column => $value) {
            $model->$column = $value;
        }

        $this->saveModel($model);

        return $this->return($request, $this->findModel($model->getAttribute('id')), 'store');
    }

    /**
     * Save a model, either from a store or an update.
     * @param Model $model
     * @return bool
     */
    protected function saveModel(Model $model)
    {
        return $model->save();
    }

    /**
     * Finds the model instance.
     * @param int|string $id
     * @param Request|null $request
     * @return Model
     */
    protected function findModel($id, Request $request = null): Model
    {
        $builder = $this->createModelQueryBuilder();

        if ($request) {
            $this->preloadRelationships($builder, $request);
        }


        $builder = $builder->findOrFail($id);
        return $builder;
    }

    /**
     * Preload any relationships required.
     * @param Builder $builder
     * @param Request $request
     * @return void
     */
    protected function preloadRelationships(Builder &$builder, Request $request): void
    {
        $headers = $request->headers;
        if (!$headers) {
            return;
        }

        $header = $headers->get('X-Load-Relationship');
        if (!$header || empty($header)) {
            return;
        }

        $relationships = array_filter(explode(',', $header));

        $builder = $builder->with($relationships);
    }

    /**
     * Shows a model. The R of CRUD.
     * @param Request $request
     * @param int $id
     * @return JsonResponse|RedirectResponse|ResponseFactory|Response|Redirector
     */
    public function show(Request $request, $id)
    {
        $model = $this->findModel($id, $request);

        $model = $this->iterateThroughChildren($model, $request);

        return $this->return($request, $model, 'show');
    }

    /**
     * Looks for an "extra" param in the route, and if it exists, looks for relationships
     * based on that route.
     * @param Model $model
     * @param Request $request
     * @return LengthAwarePaginator|Collection|Model|mixed
     * @throws BadMethodCallException
     */
    protected function iterateThroughChildren(Model $model, Request $request)
    {
        // If there's no route or extra param, just return.
        if (!$request->route() ||
            !($request->route() instanceof Route) ||
            !$request->route()->parameter('extra')) {
            return $model;
        }

        $parts = array_filter(explode('/', (string)$request->route()->parameter('extra')));

        // Loop through the parts.
        foreach ($parts as $part) {
            // Look for an array accessor, "children[5]" for example.
            preg_match('/\[(\d+)]$/', $part, $matches);
            $offset = false;

            // If one was found, save the offset and remove it from $part.
            if (!empty($matches[0])) {
                $part = str_replace(array_shift($matches), '', $part);
                $offset = array_shift($matches);
            }

            $model = $model->$part();

            // If it's a relationship, see if it's paginate-able.
            if (stripos(get_class($model), 'Many') !== false) {
                /** @var BelongsToMany|HasMany|HasOneOrMany|MorphMany|MorphOneOrMany|MorphToMany $model */
                $model = $model->paginate();
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.
}
            } elseif ($model instanceof Relation) {
                $model = $model->getResults();
            }

            // If there is an offset, get it.
            if ($offset !== false) {
                $model = $model[$offset];
            }
        }

        return $model;
    }

    /**
     * Update a record. The U of CRUD.
     * @param Request $request
     * @param int $id
     * @return JsonResponse|RedirectResponse|ResponseFactory|Response|Redirector
     */
    public function update(Request $request, $id)

    {
        $model = $this->findModel($id);

        foreach ((array)$request->input() as $column => $value) {
            $model->$column = $value;
        }

        $this->saveModel($model);

        return $this->return($request, $model, 'update');
    }

    /**
     * Destroy a model. The D of CRUD.
     * @param Request $request
     * @param int $id
     * @return ResponseFactory|Response
     * @throws Exception
     */
    public function destroy(Request $request, $id)

    {
        $model = $this->findModel($id);

        $model->delete();

        return response(null, SymResponse::HTTP_NO_CONTENT);
    }

    /**
     * Return the _links. The O of CRUD.....
     * @param Request $request
     * @return ResponseFactory|JsonResponse|RedirectResponse|Response|Redirector
     */
    public function options(Request $request)
    {
        $class = $this->newModelInstance();

        if (!($class instanceof HasLinks)) {
            throw new InvalidArgumentException('OPTIONS only works for models implementing HasLinks');
        }

        foreach ($request->input() as $key => $value) {
            $class->$key = $value;
        }

        return $this->return($request, $class->buildLinks(), 'options');
    }
}


AbstractRestfulController B
last analyzed 2020-09-02 20:23 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

1		<?php
2
3		namespace TomHart\Restful;
4
5		use BadMethodCallException;
6		use Exception;
7		use Illuminate\Contracts\Pagination\LengthAwarePaginator;
8		use Illuminate\Contracts\Routing\ResponseFactory;
9		use Illuminate\Contracts\View\Factory;
10		use Illuminate\Database\Eloquent\Builder;
		0 ignored issues – show Bug introduced 2020-01-14 22:12 UTC by Report Bug Copy Issue Report This use statement conflicts with another class in this namespace, `TomHart\Restful\Builder`. Let’s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let’s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
11		use Illuminate\Database\Eloquent\Collection;
12		use Illuminate\Database\Eloquent\Model;
13		use Illuminate\Database\Eloquent\Relations\BelongsToMany;
14		use Illuminate\Database\Eloquent\Relations\HasMany;
15		use Illuminate\Database\Eloquent\Relations\HasOneOrMany;
16		use Illuminate\Database\Eloquent\Relations\MorphMany;
17		use Illuminate\Database\Eloquent\Relations\MorphOneOrMany;
18		use Illuminate\Database\Eloquent\Relations\MorphToMany;
19		use Illuminate\Database\Eloquent\Relations\Relation;
20		use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
21		use Illuminate\Foundation\Validation\ValidatesRequests;
22		use Illuminate\Http\JsonResponse;
23		use Illuminate\Http\RedirectResponse;
24		use Illuminate\Http\Request;
25		use Illuminate\Http\Response;
26		use Illuminate\Routing\Controller as BaseController;
27		use Illuminate\Routing\Redirector;
28		use Illuminate\Routing\Route;
29		use Illuminate\Support\Str;
30		use Illuminate\View\View;
31		use InvalidArgumentException;
32		use Symfony\Component\HttpFoundation\Response as SymResponse;
33		use TomHart\Restful\Concerns\HasLinks;
34
35		abstract class AbstractRestfulController extends BaseController
36		{
37		use AuthorizesRequests;
38		use ValidatesRequests;
39
40		/**
41		* The views to render.
42		* @var string[]
43		*/
44		protected $views = [];
45
46		/**
47		* Return a list of matching models.
48		* @param Request $request
49		* @return JsonResponse\|RedirectResponse\|ResponseFactory\|Response\|Redirector
50		*/
51		public function index(Request $request)
52		{
53		$builder = $this->createModelQueryBuilder();
54
55		$input = collect($request->input())->except(config('restful.query_string_keys.page'))->toArray();
56		foreach ($input as $column => $value) {
57		$this->filterValue($builder, $column, $value);
58		}
59
60		$data = $builder->paginate(
61		$request->input('limit', null),
62		['*'],
63		config('restful.query_string_keys.page')
64		);
65
66		return $this->return($request, $data, 'index');
67		}
68
69		/**
70		* Generate a new query builder for the model.
71		* @return Builder
72		*/
73		protected function createModelQueryBuilder(): Builder
74		{
75		return $this->newModelInstance()->newQuery();
76		}
77
78		/**
79		* Creates a new model instance.
80		* @return Model
81		*/
82		protected function newModelInstance(): Model
83		{
84		$classFQDN = $this->getModelClass();
85
86		return app($classFQDN);
87		}
88
89		/**
90		* What Model class to search for entities.
91		* @return string
92		*/
93		abstract protected function getModelClass(): string;
94
95		/**
96		* Apply causes to the builder.
97		* @param Builder $builder
98		* @param string $column
99		* @param mixed $value
100		*/
101		protected function filterValue(Builder $builder, string $column, $value): void
102		{
103		$builder->where($column, $value);
104		}
105
106		/**
107		* Build and return a response.
108		* @param Request $request
109		* @param mixed $data
110		* @param string $method
111		* @return JsonResponse\|ResponseFactory\|Response\|RedirectResponse\|Redirector
112		*/
113		protected function return(Request $request, $data, string $method)
114		{
115		$status = SymResponse::HTTP_OK;
116		switch ($method) {
117		case 'store':
118		$status = SymResponse::HTTP_CREATED;
119		break;
120		}
121
122		if ($request->wantsJson()) {
123		return app(ResponseFactory::class)->json($data, $status);
124		}
125
126		if (isset($this->views[$method]) && app(Factory::class)->exists($this->views[$method])) {
127		/** @var View $view */
128		$view = view(
129		$this->views[$method],
130		[
131		'data' => $data
132		]
133		);
134
135		return response($view, $status);
136		}
137
138		switch ($method) {
139		case 'store':
140		case 'update':
141		// If it's store/update, and the user isn't asking for JSON, we want to
142		// try and redirect them to the related show record page.
143		if (($redirect = $this->redirectToShowRoute($request, $data))) {
144		return $redirect;
145		}
146		}
147
148		return app(ResponseFactory::class)->json($data, $status);
149		}
150
151		/**
152		* Redirects to the show route for the model if one exists.
153		* @param Request $request
154		* @param mixed $data
155		* @return RedirectResponse\|Redirector\|null
156		*/
157		protected function redirectToShowRoute(Request $request, $data)
158		{
159		if ($data instanceof HasLinks) {
160		$route = $data->getRouteName() . '.show';
161		$key = $data->getRouteKey();
162
163		return redirect(
164		route(
165		$route,
166		[
167		$key => $data->id
		0 ignored issues – show Bug introduced 2020-01-28 17:44 UTC by Report Bug Copy Issue Report Accessing `id` on the interface `TomHart\Restful\Concerns\HasLinks` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
168		]
169		)
170		);
171		}
172
173		/** @var Route\|null $route */
174		$route = $request->route();
175		if (!$route) {
176		return null;
177		}
178
179		$name = $route->getName();
180		if (!$name) {
		0 ignored issues – show Bug Best Practice introduced 2020-06-18 18:45 UTC by Report Bug Copy Issue Report The expression `$name` of type `string\|null` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
181		return null;
182		}
183
184		$exploded = explode('.', $name);
185		array_pop($exploded);
186		$topLevel = array_pop($exploded);
187
188		if (!$topLevel) {
189		return null;
190		}
191
192		$key = Str::singular(str_replace('-', '_', $topLevel));
193
194		return redirect(
195		route(
196		"$topLevel.show",
197		[
198		$key => $data->id
199		]
200		)
201		);
202		}
203
204		/**
205		* Handles creating a model. The C of CRUD
206		* @param Request $request
207		* @return JsonResponse\|RedirectResponse\|ResponseFactory\|Response\|Redirector
208		*/
209	View Code Duplication	public function store(Request $request)
		0 ignored issues – show Duplication introduced 2019-12-07 23:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
210		{
211		$model = $this->newModelInstance();
212
213		foreach ((array)$request->input() as $column => $value) {
214		$model->$column = $value;
215		}
216
217		$this->saveModel($model);
218
219		return $this->return($request, $this->findModel($model->getAttribute('id')), 'store');
220		}
221
222		/**
223		* Save a model, either from a store or an update.
224		* @param Model $model
225		* @return bool
226		*/
227		protected function saveModel(Model $model)
228		{
229		return $model->save();
230		}
231
232		/**
233		* Finds the model instance.
234		* @param int\|string $id
235		* @param Request\|null $request
236		* @return Model
237		*/
238		protected function findModel($id, Request $request = null): Model
239		{
240		$builder = $this->createModelQueryBuilder();
241
242		if ($request) {
243		$this->preloadRelationships($builder, $request);
244		}
245
246
247		$builder = $builder->findOrFail($id);
248		return $builder;
249		}
250
251		/**
252		* Preload any relationships required.
253		* @param Builder $builder
254		* @param Request $request
255		* @return void
256		*/
257		protected function preloadRelationships(Builder &$builder, Request $request): void
258		{
259		$headers = $request->headers;
260		if (!$headers) {
261		return;
262		}
263
264		$header = $headers->get('X-Load-Relationship');
265		if (!$header \|\| empty($header)) {
266		return;
267		}
268
269		$relationships = array_filter(explode(',', $header));
270
271		$builder = $builder->with($relationships);
272		}
273
274		/**
275		* Shows a model. The R of CRUD.
276		* @param Request $request
277		* @param int $id
278		* @return JsonResponse\|RedirectResponse\|ResponseFactory\|Response\|Redirector
279		*/
280		public function show(Request $request, $id)
281		{
282		$model = $this->findModel($id, $request);
283
284		$model = $this->iterateThroughChildren($model, $request);
285
286		return $this->return($request, $model, 'show');
287		}
288
289		/**
290		* Looks for an "extra" param in the route, and if it exists, looks for relationships
291		* based on that route.
292		* @param Model $model
293		* @param Request $request
294		* @return LengthAwarePaginator\|Collection\|Model\|mixed
295		* @throws BadMethodCallException
296		*/
297		protected function iterateThroughChildren(Model $model, Request $request)
298		{
299		// If there's no route or extra param, just return.
300		if (!$request->route() \|\|
301		!($request->route() instanceof Route) \|\|
302		!$request->route()->parameter('extra')) {
303		return $model;
304		}
305
306		$parts = array_filter(explode('/', (string)$request->route()->parameter('extra')));
307
308		// Loop through the parts.
309		foreach ($parts as $part) {
310		// Look for an array accessor, "children[5]" for example.
311		preg_match('/\[(\d+)]$/', $part, $matches);
312		$offset = false;
313
314		// If one was found, save the offset and remove it from $part.
315		if (!empty($matches[0])) {
316		$part = str_replace(array_shift($matches), '', $part);
317		$offset = array_shift($matches);
318		}
319
320		$model = $model->$part();
321
322		// If it's a relationship, see if it's paginate-able.
323		if (stripos(get_class($model), 'Many') !== false) {
324		/** @var BelongsToMany\|HasMany\|HasOneOrMany\|MorphMany\|MorphOneOrMany\|MorphToMany $model */
325		$model = $model->paginate();
		0 ignored issues – show Bug introduced 2020-01-11 21:12 UTC by Report Bug Copy Issue Report The method `paginate` does only exist in `Illuminate\Database\Eloq...Relations\BelongsToMany`, but not in `Illuminate\Database\Eloq...\Relations\HasOneOrMany`. 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...
326		} elseif ($model instanceof Relation) {
327		$model = $model->getResults();
328		}
329
330		// If there is an offset, get it.
331		if ($offset !== false) {
332		$model = $model[$offset];
333		}
334		}
335
336		return $model;
337		}
338
339		/**
340		* Update a record. The U of CRUD.
341		* @param Request $request
342		* @param int $id
343		* @return JsonResponse\|RedirectResponse\|ResponseFactory\|Response\|Redirector
344		*/
345	View Code Duplication	public function update(Request $request, $id)
		0 ignored issues – show Duplication introduced 2019-12-07 23:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
346		{
347		$model = $this->findModel($id);
348
349		foreach ((array)$request->input() as $column => $value) {
350		$model->$column = $value;
351		}
352
353		$this->saveModel($model);
354
355		return $this->return($request, $model, 'update');
356		}
357
358		/**
359		* Destroy a model. The D of CRUD.
360		* @param Request $request
361		* @param int $id
362		* @return ResponseFactory\|Response
363		* @throws Exception
364		*/
365		public function destroy(Request $request, $id)
		0 ignored issues – show Unused Code introduced 2019-12-07 23:12 UTC by Report Bug Copy Issue Report The parameter `$request` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
366		{
367		$model = $this->findModel($id);
368
369		$model->delete();
370
371		return response(null, SymResponse::HTTP_NO_CONTENT);
372		}
373
374		/**
375		* Return the _links. The O of CRUD.....
376		* @param Request $request
377		* @return ResponseFactory\|JsonResponse\|RedirectResponse\|Response\|Redirector
378		*/
379		public function options(Request $request)
380		{
381		$class = $this->newModelInstance();
382
383		if (!($class instanceof HasLinks)) {
384		throw new InvalidArgumentException('OPTIONS only works for models implementing HasLinks');
385		}
386
387		foreach ($request->input() as $key => $value) {
388		$class->$key = $value;
389		}
390
391		return $this->return($request, $class->buildLinks(), 'options');
392		}
393		}
394

TomHart / laravel-restful-controller

AbstractRestfulController B last analyzed 2020-09-02 20:23 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

AbstractRestfulController B
last analyzed 2020-09-02 20:23 UTC