View GitHub Repository hasin

Schedule Inspection
Subscribe
Test Failed
Pull Request — master (#42)
by Yunfeng
06:05
created
Status
Category
Toggle Patches
database/migrations/create_hasin_test_table.php 1 patch
Spacing   +13 added lines, -13 removed lines patch added patch discarded remove patch 
@@ -12,64 +12,64 @@  discard block
 
 block discarded – undo
12 12 
      */
13 13 
     public function up()
14 14 
     {
15 
-        Schema::create('histories', function (Blueprint $table) {
15 
+        Schema::create('histories', function(Blueprint $table) {
16 16 
             $table->id();
17 17 
             $table->bigInteger('user_id')->default(0);
18 18 
             $table->string('content');
19 19 
             $table->timestamps();
20 20 
         });
21 
-        Schema::create('comments', function (Blueprint $table) {
21 
+        Schema::create('comments', function(Blueprint $table) {
22 22 
             $table->id();
23 23 
             $table->morphs('commentable');
24 24 
             $table->string('content');
25 25 
             $table->tinyInteger('status')->default(0);
26 26 
             $table->timestamps();
27 27 
         });
28 
-        Schema::create('countries', function (Blueprint $table) {
28 
+        Schema::create('countries', function(Blueprint $table) {
29 29 
             $table->id();
30 30 
             $table->string('name')->default('');
31 31 
             $table->timestamps();
32 32 
         });
33 
-        Schema::create('images', function (Blueprint $table) {
33 
+        Schema::create('images', function(Blueprint $table) {
34 34 
             $table->id();
35 35 
             $table->string('url')->default('');
36 36 
             $table->morphs('imageable');
37 37 
             $table->timestamps();
38 38 
         });
39 
-        Schema::create('phones', function (Blueprint $table) {
39 
+        Schema::create('phones', function(Blueprint $table) {
40 40 
             $table->id();
41 41 
             $table->bigInteger('user_id')->default(0);
42 42 
             $table->string('phone_number')->default('');
43 43 
             $table->timestamps();
44 44 
         });
45 
-        Schema::create('roles', function (Blueprint $table) {
45 
+        Schema::create('roles', function(Blueprint $table) {
46 46 
             $table->id();
47 47 
             $table->string('name');
48 48 
             $table->timestamps();
49 49 
         });
50 
-        Schema::create('role_user', function (Blueprint $table) {
50 
+        Schema::create('role_user', function(Blueprint $table) {
51 51 
             $table->id();
52 52 
             $table->bigInteger('user_id')->default(0);
53 53 
             $table->bigInteger('role_id')->default(0);
54 54 
             $table->timestamps();
55 55 
         });
56 
-        Schema::create('suppliers', function (Blueprint $table) {
56 
+        Schema::create('suppliers', function(Blueprint $table) {
57 57 
             $table->id();
58 58 
             $table->string('name')->default('');
59 59 
             $table->timestamps();
60 60 
         });
61 
-        Schema::create('tags', function (Blueprint $table) {
61 
+        Schema::create('tags', function(Blueprint $table) {
62 62 
             $table->id();
63 63 
             $table->string('name')->default('');
64 64 
             $table->timestamps();
65 65 
         });
66 
-        Schema::create('taggables', function (Blueprint $table) {
66 
+        Schema::create('taggables', function(Blueprint $table) {
67 67 
             $table->id();
68 68 
             $table->bigInteger('tag_id')->default(0);
69 69 
             $table->morphs('taggable');
70 70 
             $table->timestamps();
71 71 
         });
72 
-        Schema::create('users', function (Blueprint $table) {
72 
+        Schema::create('users', function(Blueprint $table) {
73 73 
             $table->id();
74 74 
             $table->string('username')->default('');
75 75 
             $table->tinyInteger('age')->default(0);
 
@@ -77,12 +77,12 @@  discard block
 
 block discarded – undo
77 77 
             $table->bigInteger('supplier_id')->default(0);
78 78 
             $table->timestamps();
79 79 
         });
80 
-        Schema::create('videos', function (Blueprint $table) {
80 
+        Schema::create('videos', function(Blueprint $table) {
81 81 
             $table->id();
82 82 
             $table->string('name')->default('');
83 83 
             $table->timestamps();
84 84 
         });
85 
-        Schema::create('posts', function (Blueprint $table) {
85 
+        Schema::create('posts', function(Blueprint $table) {
86 86 
             $table->id();
87 87 
             $table->bigInteger('user_id')->default(0);
88 88 
             $table->string('title')->default('');
Please login to merge, or discard this patch.
src/Database/Eloquent/BuilderMixin.php 1 patch
Spacing   +34 added lines, -34 removed lines patch added patch discarded remove patch 
@@ -17,7 +17,7 @@  discard block
 
 block discarded – undo
17 17 
      */
18 18 
     public function hasIn(): Closure
19 19 
     {
20 
-        return function ($relation, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null): Builder {
20 
+        return function($relation, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null): Builder {
21 21 
             /** @var Builder $this */
22 22 
             if (is_string($relation)) {
23 23 
                 if (str_contains($relation, '.')) {
 
@@ -28,7 +28,7 @@  discard block
 
 block discarded – undo
28 28 
             }
29 29
30 30 
             if ($relation instanceof MorphTo) {
31 
-                return $this->hasMorphIn($relation, ['*'], $operator, $count, $boolean, $callback);
31 
+                return $this->hasMorphIn($relation, [ '*' ], $operator, $count, $boolean, $callback);
32 32 
             }
33 33
34 34 
             // If we only need to check for the existence of the relation, then we can optimize
 
@@ -69,7 +69,7 @@  discard block
 
 block discarded – undo
69 69 
      */
70 70 
     protected function hasInNested(): Closure
71 71 
     {
72 
-        return function ($relations, $operator = '>=', $count = 1, $boolean = 'and', $callback = null): Builder {
72 
+        return function($relations, $operator = '>=', $count = 1, $boolean = 'and', $callback = null): Builder {
73 73 
             /** @var Builder $this */
74 74 
             $relations = explode('.', $relations);
75 75 
 
@@ -80,7 +80,7 @@  discard block
 
 block discarded – undo
80 80 
                 $count = 1;
81 81 
             }
82 82
83 
-            $closure = function ($q) use (&$closure, &$relations, $operator, $count, $callback) {
83 
+            $closure = function($q) use (&$closure, &$relations, $operator, $count, $callback) {
84 84 
                 // In order to nest "hasIn", we need to add count relation constraints on the
85 85 
                 // callback Closure. We'll do this by simply passing the Closure its own
86 86 
                 // reference to itself so it calls itself recursively on each segment.
 
@@ -100,7 +100,7 @@  discard block
 
 block discarded – undo
100 100 
      */
101 101 
     public function orHasIn(): Closure
102 102 
     {
103 
-        return function ($relation, $operator = '>=', $count = 1): Builder {
103 
+        return function($relation, $operator = '>=', $count = 1): Builder {
104 104 
             /** @var Builder $this */
105 105 
             return $this->hasIn($relation, $operator, $count, 'or');
106 106 
         };
 
@@ -113,7 +113,7 @@  discard block
 
 block discarded – undo
113 113 
      */
114 114 
     public function doesntHaveIn(): Closure
115 115 
     {
116 
-        return function ($relation, $boolean = 'and', Closure $callback = null): Builder {
116 
+        return function($relation, $boolean = 'and', Closure $callback = null): Builder {
117 117 
             /** @var Builder $this */
118 118 
             return $this->hasIn($relation, '<', 1, $boolean, $callback);
119 119 
         };
 
@@ -126,7 +126,7 @@  discard block
 
 block discarded – undo
126 126 
      */
127 127 
     public function orDoesntHaveIn(): Closure
128 128 
     {
129 
-        return function ($relation): Builder {
129 
+        return function($relation): Builder {
130 130 
             /** @var Builder $this */
131 131 
             return $this->doesntHaveIn($relation, 'or');
132 132 
         };
 
@@ -139,7 +139,7 @@  discard block
 
 block discarded – undo
139 139 
      */
140 140 
     public function whereHasIn(): Closure
141 141 
     {
142 
-        return function ($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
142 
+        return function($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
143 143 
             /** @var Builder $this */
144 144 
             return $this->hasIn($relation, $operator, $count, 'and', $callback);
145 145 
         };
 
@@ -154,10 +154,10 @@  discard block
 
 block discarded – undo
154 154 
      */
155 155 
     public function withWhereHasIn(): Closure
156 156 
     {
157 
-        return function ($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
157 
+        return function($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
158 158 
             /** @var Builder $this */
159 159 
             return $this->whereHasIn(Str::before($relation, ':'), $callback, $operator, $count)
160 
-                ->with($callback ? [$relation => fn ($query) => $callback($query)] : $relation);
160 
+                ->with($callback ? [ $relation => fn ($query) => $callback($query) ] : $relation);
161 161 
         };
162 162 
     }
163 163 
 
@@ -168,7 +168,7 @@  discard block
 
 block discarded – undo
168 168 
      */
169 169 
     public function orWhereHasIn(): Closure
170 170 
     {
171 
-        return function ($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
171 
+        return function($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
172 172 
             /** @var Builder $this */
173 173 
             return $this->hasIn($relation, $operator, $count, 'or', $callback);
174 174 
         };
 
@@ -181,7 +181,7 @@  discard block
 
 block discarded – undo
181 181 
      */
182 182 
     public function whereDoesntHaveIn(): Closure
183 183 
     {
184 
-        return function ($relation, Closure $callback = null): Builder {
184 
+        return function($relation, Closure $callback = null): Builder {
185 185 
             /** @var Builder $this */
186 186 
             return $this->doesntHaveIn($relation, 'and', $callback);
187 187 
         };
 
@@ -194,7 +194,7 @@  discard block
 
 block discarded – undo
194 194 
      */
195 195 
     public function orWhereDoesntHaveIn(): Closure
196 196 
     {
197 
-        return function ($relation, Closure $callback = null): Builder {
197 
+        return function($relation, Closure $callback = null): Builder {
198 198 
             /** @var Builder $this */
199 199 
             return $this->doesntHaveIn($relation, 'or', $callback);
200 200 
         };
 
@@ -207,7 +207,7 @@  discard block
 
 block discarded – undo
207 207 
      */
208 208 
     public function hasMorphIn(): Closure
209 209 
     {
210 
-        return function ($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null): Builder {
210 
+        return function($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null): Builder {
211 211 
             /** @var Builder $this */
212 212 
             if (is_string($relation)) {
213 213 
                 $relation = $this->getRelationWithoutConstraints($relation);
 
@@ -215,7 +215,7 @@  discard block
 
 block discarded – undo
215 215
216 216 
             $types = (array) $types;
217 217
218 
-            if ($types === ['*']) {
218 
+            if ($types === [ '*' ]) {
219 219 
                 $types = $this->model->newModelQuery()->distinct()->pluck($relation->getMorphType())->filter()->all();
220 220 
             }
221 221 
 
@@ -223,13 +223,13 @@  discard block
 
 block discarded – undo
223 223 
                 $type = Relation::getMorphedModel($type) ?? $type;
224 224 
             }
225 225
226 
-            return $this->where(function ($query) use ($relation, $callback, $operator, $count, $types) {
226 
+            return $this->where(function($query) use ($relation, $callback, $operator, $count, $types) {
227 227 
                 foreach ($types as $type) {
228 
-                    $query->orWhere(function ($query) use ($relation, $callback, $operator, $count, $type) {
228 
+                    $query->orWhere(function($query) use ($relation, $callback, $operator, $count, $type) {
229 229 
                         $belongsTo = $this->getBelongsToRelation($relation, $type);
230 230
231 231 
                         if ($callback) {
232 
-                            $callback = function ($query) use ($callback, $type) {
232 
+                            $callback = function($query) use ($callback, $type) {
233 233 
                                 return $callback($query, $type);
234 234 
                             };
235 235 
                         }
 
@@ -249,7 +249,7 @@  discard block
 
 block discarded – undo
249 249 
      */
250 250 
     public function orHasMorphIn(): Closure
251 251 
     {
252 
-        return function ($relation, $types, $operator = '>=', $count = 1): Builder {
252 
+        return function($relation, $types, $operator = '>=', $count = 1): Builder {
253 253 
             /** @var Builder $this */
254 254 
             return $this->hasMorphIn($relation, $types, $operator, $count, 'or');
255 255 
         };
 
@@ -262,7 +262,7 @@  discard block
 
 block discarded – undo
262 262 
      */
263 263 
     public function doesntHaveMorphIn(): Closure
264 264 
     {
265 
-        return function ($relation, $types, $boolean = 'and', Closure $callback = null): Builder {
265 
+        return function($relation, $types, $boolean = 'and', Closure $callback = null): Builder {
266 266 
             /** @var Builder $this */
267 267 
             return $this->hasMorphIn($relation, $types, '<', 1, $boolean, $callback);
268 268 
         };
 
@@ -275,7 +275,7 @@  discard block
 
 block discarded – undo
275 275 
      */
276 276 
     public function orDoesntHaveMorphIn(): Closure
277 277 
     {
278 
-        return function ($relation, $types): Builder {
278 
+        return function($relation, $types): Builder {
279 279 
             /** @var Builder $this */
280 280 
             return $this->doesntHaveMorphIn($relation, $types, 'or');
281 281 
         };
 
@@ -288,7 +288,7 @@  discard block
 
 block discarded – undo
288 288 
      */
289 289 
     public function whereHasMorphIn(): Closure
290 290 
     {
291 
-        return function ($relation, $types, Closure $callback = null, $operator = '>=', $count = 1): Builder {
291 
+        return function($relation, $types, Closure $callback = null, $operator = '>=', $count = 1): Builder {
292 292 
             /** @var Builder $this */
293 293 
             return $this->hasMorphIn($relation, $types, $operator, $count, 'and', $callback);
294 294 
         };
 
@@ -301,7 +301,7 @@  discard block
 
 block discarded – undo
301 301 
      */
302 302 
     public function orWhereHasMorphIn(): Closure
303 303 
     {
304 
-        return function ($relation, $types, Closure $callback = null, $operator = '>=', $count = 1): Builder {
304 
+        return function($relation, $types, Closure $callback = null, $operator = '>=', $count = 1): Builder {
305 305 
             /** @var Builder $this */
306 306 
             return $this->hasMorphIn($relation, $types, $operator, $count, 'or', $callback);
307 307 
         };
 
@@ -314,7 +314,7 @@  discard block
 
 block discarded – undo
314 314 
      */
315 315 
     public function whereDoesntHaveMorphIn(): Closure
316 316 
     {
317 
-        return function ($relation, $types, Closure $callback = null): Builder {
317 
+        return function($relation, $types, Closure $callback = null): Builder {
318 318 
             /** @var Builder $this */
319 319 
             return $this->doesntHaveMorphIn($relation, $types, 'and', $callback);
320 320 
         };
 
@@ -327,7 +327,7 @@  discard block
 
 block discarded – undo
327 327 
      */
328 328 
     public function orWhereDoesntHaveMorphIn(): Closure
329 329 
     {
330 
-        return function ($relation, $types, Closure $callback = null): Builder {
330 
+        return function($relation, $types, Closure $callback = null): Builder {
331 331 
             /** @var Builder $this */
332 332 
             return $this->doesntHaveMorphIn($relation, $types, 'or', $callback);
333 333 
         };
 
@@ -340,8 +340,8 @@  discard block
 
 block discarded – undo
340 340 
      */
341 341 
     public function whereRelationIn(): Closure
342 342 
     {
343 
-        return function ($relation, $column, $operator = null, $value = null): Builder {
344 
-            return $this->whereHasIn($relation, function ($query) use ($column, $operator, $value) {
343 
+        return function($relation, $column, $operator = null, $value = null): Builder {
344 
+            return $this->whereHasIn($relation, function($query) use ($column, $operator, $value) {
345 345 
                 if ($column instanceof Closure) {
346 346 
                     $column($query);
347 347 
                 } else {
 
@@ -358,8 +358,8 @@  discard block
 
 block discarded – undo
358 358 
      */
359 359 
     public function orWhereRelationIn(): Closure
360 360 
     {
361 
-        return function ($relation, $column, $operator = null, $value = null): Builder {
362 
-            return $this->orWhereHasIn($relation, function ($query) use ($column, $operator, $value) {
361 
+        return function($relation, $column, $operator = null, $value = null): Builder {
362 
+            return $this->orWhereHasIn($relation, function($query) use ($column, $operator, $value) {
363 363 
                 if ($column instanceof Closure) {
364 364 
                     $column($query);
365 365 
                 } else {
 
@@ -376,8 +376,8 @@  discard block
 
 block discarded – undo
376 376 
      */
377 377 
     public function whereMorphRelationIn(): Closure
378 378 
     {
379 
-        return function ($relation, $types, $column, $operator = null, $value = null): Builder {
380 
-            return $this->whereHasMorphIn($relation, $types, function ($query) use ($column, $operator, $value) {
379 
+        return function($relation, $types, $column, $operator = null, $value = null): Builder {
380 
+            return $this->whereHasMorphIn($relation, $types, function($query) use ($column, $operator, $value) {
381 381 
                 $query->where($column, $operator, $value);
382 382 
             });
383 383 
         };
 
@@ -390,8 +390,8 @@  discard block
 
 block discarded – undo
390 390 
      */
391 391 
     public function orWhereMorphRelationIn(): Closure
392 392 
     {
393 
-        return function ($relation, $types, $column, $operator = null, $value = null): Builder {
394 
-            return $this->orWhereHasMorphIn($relation, $types, function ($query) use ($column, $operator, $value) {
393 
+        return function($relation, $types, $column, $operator = null, $value = null): Builder {
394 
+            return $this->orWhereHasMorphIn($relation, $types, function($query) use ($column, $operator, $value) {
395 395 
                 $query->where($column, $operator, $value);
396 396 
             });
397 397 
         };
 
@@ -404,7 +404,7 @@  discard block
 
 block discarded – undo
404 404 
      */
405 405 
     protected function addHasInWhere(): Closure
406 406 
     {
407 
-        return function (Builder $hasInQuery, Relation $relation, $operator, $count, $boolean): Builder {
407 
+        return function(Builder $hasInQuery, Relation $relation, $operator, $count, $boolean): Builder {
408 408 
             /** @var Builder $this */
409 409 
             $hasInQuery->mergeConstraintsFrom($relation->getQuery());
410 410
Please login to merge, or discard this patch.
src/Database/Eloquent/RelationMixin.php 1 patch
Spacing   +10 added lines, -10 removed lines patch added patch discarded remove patch 
@@ -18,12 +18,12 @@  discard block
 
 block discarded – undo
18 18 
 {
19 19 
     public function getRelationExistenceInQuery(): Closure
20 20 
     {
21 
-        return function (Builder $query, Builder $parentQuery, $columns = ['*']): Builder {
22 
-            $relation = function (Builder $query, Builder $parentQuery, $columns = ['*']): Builder {
21 
+        return function(Builder $query, Builder $parentQuery, $columns = [ '*' ]): Builder {
22 
+            $relation = function(Builder $query, Builder $parentQuery, $columns = [ '*' ]): Builder {
23 23 
                 return $query->select($columns);
24 24 
             };
25 25 
             // basic builder
26 
-            $belongsTo = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
26 
+            $belongsTo = function(Builder $query, Builder $parentQuery) use ($relation): Builder {
27 27 
                 $columns = $query->qualifyColumn($this->ownerKey);
28 28
29 29 
                 $relationQuery = $relation($query, $parentQuery, $columns);
 
@@ -38,7 +38,7 @@  discard block
 
 block discarded – undo
38 38
39 39 
                 return $relationQuery;
40 40 
             };
41 
-            $belongsToMany = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
41 
+            $belongsToMany = function(Builder $query, Builder $parentQuery) use ($relation): Builder {
42 42 
                 $columns = $this->getExistenceCompareKey();
43 43 
                 if ($parentQuery->getQuery()->from == $query->getQuery()->from) {
44 44 
                     $query->select($columns);
 
@@ -52,7 +52,7 @@  discard block
 
 block discarded – undo
52 52
53 53 
                 return $relation($query, $parentQuery, $columns);
54 54 
             };
55 
-            $hasOneOrMany = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
55 
+            $hasOneOrMany = function(Builder $query, Builder $parentQuery) use ($relation): Builder {
56 56 
                 $columns = $this->getExistenceCompareKey();
57 57 
                 if ($query->getQuery()->from == $parentQuery->getQuery()->from) {
58 58 
                     $query->from($query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash());
 
@@ -62,7 +62,7 @@  discard block
 
 block discarded – undo
62 62
63 63 
                 return $relation($query, $parentQuery, $columns);
64 64 
             };
65 
-            $hasManyThrough = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
65 
+            $hasManyThrough = function(Builder $query, Builder $parentQuery) use ($relation): Builder {
66 66 
                 $columns = $this->getQualifiedFirstKeyName();
67 67 
                 if ($parentQuery->getQuery()->from === $query->getQuery()->from) {
68 68 
                     $query->from($query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash());
 
@@ -95,27 +95,27 @@  discard block
 
 block discarded – undo
95 95 
                 return $relation($query, $parentQuery, $columns);
96 96 
             };
97 97 
             // extended builder
98 
-            $hasOne = function (Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
98 
+            $hasOne = function(Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
99 99 
                 if ($this->isOneOfMany()) {
100 100 
                     $this->mergeOneOfManyJoinsTo($query);
101 101 
                 }
102 102
103 103 
                 return $hasOneOrMany($query, $parentQuery);
104 104 
             };
105 
-            $morphOneOrMany = function (Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
105 
+            $morphOneOrMany = function(Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
106 106 
                 return $hasOneOrMany($query, $parentQuery)->where(
107 107 
                     $query->qualifyColumn($this->getMorphType()),
108 108 
                     $this->morphClass
109 109 
                 );
110 110 
             };
111 
-            $morphOne = function (Builder $query, Builder $parentQuery) use ($morphOneOrMany): Builder {
111 
+            $morphOne = function(Builder $query, Builder $parentQuery) use ($morphOneOrMany): Builder {
112 112 
                 if ($this->isOneOfMany()) {
113 113 
                     $this->mergeOneOfManyJoinsTo($query);
114 114 
                 }
115 115
116 116 
                 return $morphOneOrMany($query, $parentQuery);
117 117 
             };
118 
-            $morphToMany = function (Builder $query, Builder $parentQuery) use ($belongsToMany): Builder {
118 
+            $morphToMany = function(Builder $query, Builder $parentQuery) use ($belongsToMany): Builder {
119 119 
                 return $belongsToMany($query, $parentQuery)->where(
120 120 
                     $this->qualifyPivotColumn($this->morphType),
121 121 
                     $this->morphClass
Please login to merge, or discard this patch.