ModuleController::determineModelClass() - Code Metrics - Inspection of "Autumn cleanup" - spatie-custom/blender - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#79)

by Sebastian

created 2016-10-18 12:08 UTC

ModuleController::determineModelClass() A

↳ Parent: ModuleController

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0

<?php

namespace App\Http\Controllers\Back;

use Cache;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Support\Collection;
use ReflectionClass;
use Spatie\EloquentSortable\SortableInterface;

abstract class ModuleController
{
    use Updaters\UpdateMedia;
    use Updaters\UpdateOnlineToggle;
    use Updaters\UpdatePublishDate;
    use Updaters\UpdateSeoValues;
    use Updaters\UpdateTags;
    use Updaters\UpdateTranslations;

    /** @var string */
    protected $modelClass, $moduleName;


    /** @var bool */
    protected $redirectToIndex = false;

    public function __construct()
    {
        $this->modelClass = $this->determineModelClass();
        $this->moduleName = $this->determineModuleName();
    }

    public function index()
    {
        $models = $this->all();

        return view("back.{$this->moduleName}.index")->with('models', $models);
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 create()
    {
        $model = $this->make();

        return redirect()->to($this->action('edit', $model->id));
    }

    public function show($id)
    {
        return redirect()->to($this->action('edit', $id));
    }

    public function edit(int $id)
    {
        $model = $this->find($id);

        if (request()->has('revert')) {
            $model->clearTemporaryMedia();

            return redirect()->to($this->action('edit', $id));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return view("back.{$this->moduleName}.edit")
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.
}
            ->with('model', $model)
            ->with('module', $this->moduleName);
    }

    public function update(int $id)
    {
        $formRequest = $this->determineUpdateRequestClass();

        $request = app()->make($formRequest);

        $model = $this->find($id);

        $this->updateFromRequest($model, $request);


        Cache::flush();

        $eventDescription = $this->updatedEventDescriptionFor($model);
        activity()->on($model)->log($eventDescription);
        flash()->success(strip_tags($eventDescription));

        return redirect()->to(
            $this->redirectToIndex ? $this->action('index') : $this->action('edit', $model->id)
        );
    }

    public function destroy($id)
    {
        $model = $this->query()->find($id);


        $eventDescription = $this->deletedEventDescriptionFor($model);
        activity()->log($eventDescription);
        flash()->success(strip_tags($eventDescription));

        $model->delete();

        Cache::flush();

        return redirect()->to($this->action('index'));
    }

    public function changeOrder(Request $request)
    {
        call_user_func([$this->modelClass, 'setNewOrder'], $request->get('ids'));
    }

    protected function find(int $id): Model
    {
        return call_user_func("{$this->modelClass}::findOrFail", $id);
    }

    protected function all(): Collection
    {
        $query = call_user_func("{$this->modelClass}::query")->nonDraft();

        if (array_key_exists(SortableInterface::class, class_implements($this->modelClass))) {
            $query->orderBy('order_column', 'asc');
        }

        return $query->get();
    }

    protected function determineModelClass(): string
    {
        return (new ReflectionClass($this))
            ->getMethod('make')
            ->getReturnType();
    }

    protected function determineModuleName(): string
    {
        return explode('_', snake_case(short_class_name($this), '_'), 2)[0];
    }

    protected function determineUpdateRequestClass(): string
    {
        return (new ReflectionClass($this))
            ->getMethod('updateFromRequest')
            ->getParameters()[1]
            ->getClass()
            ->getName();
    }

    protected function updateModel(Model $model, FormRequest $request)
    {
        $this->updateTranslations($model, $request);
        $this->updateMedia($model, $request);
        $this->updateOnlineToggle($model, $request);
        $this->updatePublishDate($model, $request);
        $this->updateSeoValues($model, $request);

        $model->save();
    }

    protected function updatedEventDescriptionFor($model): string
    {
        $modelName = fragment("back.{$this->moduleName}.singular");

        $linkToModel = el('a', ['href' => $this->action('edit', $model->id)], $model->name);

        if ($model->wasDraft) {
            return fragment('back.events.created', ['model' => $modelName, 'name' => $linkToModel]);
        }

        return fragment('back.events.updated', ['model' => $modelName, 'name' => $linkToModel]);
    }

    protected function deletedEventDescriptionFor($model): string
    {
        $modelName = fragment("back.{$this->moduleName}.singular");

        return fragment('back.events.deleted', ['model' => $modelName, 'name' => $model->name]);
    }

    protected function action(string $action, $parameters = []): string
    {
        return action('\\'.static::class.'@'.$action, $parameters);
    }
}


1			<?php
2
3			namespace App\Http\Controllers\Back;
4
5			use Cache;
6			use Illuminate\Database\Eloquent\Model;
7			use Illuminate\Foundation\Http\FormRequest;
8			use Illuminate\Support\Collection;
9			use ReflectionClass;
10			use Spatie\EloquentSortable\SortableInterface;
11
12			abstract class ModuleController
13			{
14			use Updaters\UpdateMedia;
15			use Updaters\UpdateOnlineToggle;
16			use Updaters\UpdatePublishDate;
17			use Updaters\UpdateSeoValues;
18			use Updaters\UpdateTags;
19			use Updaters\UpdateTranslations;
20
21			/** @var string */
22			protected $modelClass, $moduleName;
			0 ignored issues – show Coding Style introduced 2016-10-18 11:00 UTC by Report Bug Copy Issue Report It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history...
23
24			/** @var bool */
25			protected $redirectToIndex = false;
26
27			public function __construct()
28			{
29			$this->modelClass = $this->determineModelClass();
30			$this->moduleName = $this->determineModuleName();
31			}
32
33			public function index()
34			{
35			$models = $this->all();
36
37			return view("back.{$this->moduleName}.index")->with('models', $models);
			0 ignored issues – show Bug introduced 2016-10-18 11:00 UTC by Report Bug Copy Issue Report The method `with` does only exist in `Illuminate\View\View`, but not in `Illuminate\Contracts\View\Factory`. 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...
38			}
39
40			public function create()
41			{
42			$model = $this->make();
43
44			return redirect()->to($this->action('edit', $model->id));
45			}
46
47			public function show($id)
48			{
49			return redirect()->to($this->action('edit', $id));
50			}
51
52			public function edit(int $id)
53			{
54			$model = $this->find($id);
55
56			if (request()->has('revert')) {
57			$model->clearTemporaryMedia();
58
59			return redirect()->to($this->action('edit', $id));
			0 ignored issues – show Documentation introduced 2016-10-18 11:00 UTC by Report Bug Copy Issue Report `$id` is of type `integer`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
60			}
61
62			return view("back.{$this->moduleName}.edit")
			0 ignored issues – show Bug introduced 2016-10-18 11:00 UTC by Report Bug Copy Issue Report The method `with` does only exist in `Illuminate\View\View`, but not in `Illuminate\Contracts\View\Factory`. 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...
63			->with('model', $model)
64			->with('module', $this->moduleName);
65			}
66
67			public function update(int $id)
68			{
69			$formRequest = $this->determineUpdateRequestClass();
70
71			$request = app()->make($formRequest);
72
73			$model = $this->find($id);
74
75			$this->updateFromRequest($model, $request);
			0 ignored issues – show Bug introduced 2016-10-18 11:00 UTC by Report Bug Copy Issue Report The method `updateFromRequest()` does not exist on `App\Http\Controllers\Back\ModuleController`. Did you maybe mean `update()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
76
77			Cache::flush();
78
79			$eventDescription = $this->updatedEventDescriptionFor($model);
80			activity()->on($model)->log($eventDescription);
81			flash()->success(strip_tags($eventDescription));
82
83			return redirect()->to(
84			$this->redirectToIndex ? $this->action('index') : $this->action('edit', $model->id)
85			);
86			}
87
88			public function destroy($id)
89			{
90			$model = $this->query()->find($id);
			0 ignored issues – show Bug introduced 2016-10-18 11:00 UTC by Report Bug Copy Issue Report The method `query()` does not seem to exist on `object<App\Http\Controll...\Back\ModuleController>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
91
92			$eventDescription = $this->deletedEventDescriptionFor($model);
93			activity()->log($eventDescription);
94			flash()->success(strip_tags($eventDescription));
95
96			$model->delete();
97
98			Cache::flush();
99
100			return redirect()->to($this->action('index'));
101			}
102
103			public function changeOrder(Request $request)
104			{
105			call_user_func([$this->modelClass, 'setNewOrder'], $request->get('ids'));
106			}
107
108			protected function find(int $id): Model
109			{
110			return call_user_func("{$this->modelClass}::findOrFail", $id);
111			}
112
113			protected function all(): Collection
114			{
115			$query = call_user_func("{$this->modelClass}::query")->nonDraft();
116
117			if (array_key_exists(SortableInterface::class, class_implements($this->modelClass))) {
118			$query->orderBy('order_column', 'asc');
119			}
120
121			return $query->get();
122			}
123
124			protected function determineModelClass(): string
125			{
126			return (new ReflectionClass($this))
127			->getMethod('make')
128			->getReturnType();
129			}
130
131			protected function determineModuleName(): string
132			{
133			return explode('_', snake_case(short_class_name($this), '_'), 2)[0];
134			}
135
136			protected function determineUpdateRequestClass(): string
137			{
138			return (new ReflectionClass($this))
139			->getMethod('updateFromRequest')
140			->getParameters()[1]
141			->getClass()
142			->getName();
143			}
144
145			protected function updateModel(Model $model, FormRequest $request)
146			{
147			$this->updateTranslations($model, $request);
148			$this->updateMedia($model, $request);
149			$this->updateOnlineToggle($model, $request);
150			$this->updatePublishDate($model, $request);
151			$this->updateSeoValues($model, $request);
152
153			$model->save();
154			}
155
156			protected function updatedEventDescriptionFor($model): string
157			{
158			$modelName = fragment("back.{$this->moduleName}.singular");
159
160			$linkToModel = el('a', ['href' => $this->action('edit', $model->id)], $model->name);
161
162			if ($model->wasDraft) {
163			return fragment('back.events.created', ['model' => $modelName, 'name' => $linkToModel]);
164			}
165
166			return fragment('back.events.updated', ['model' => $modelName, 'name' => $linkToModel]);
167			}
168
169			protected function deletedEventDescriptionFor($model): string
170			{
171			$modelName = fragment("back.{$this->moduleName}.singular");
172
173			return fragment('back.events.deleted', ['model' => $modelName, 'name' => $model->name]);
174			}
175
176			protected function action(string $action, $parameters = []): string
177			{
178			return action('\\'.static::class.'@'.$action, $parameters);
179			}
180			}
181

spatie-custom / blender

Pull Request — master (#79)

ModuleController::determineModelClass() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like