biiiiiigmonster / hasin

database/migrations/create_hasin_test_table.php

Spacing +13 added lines, -13 removed lines

@@ -12,64 +12,64 @@ 
      */
     public function up()
     {
-        Schema::create('histories', function (Blueprint $table) {
+        Schema::create('histories', function(Blueprint $table) {
             $table->id();
             $table->bigInteger('user_id')->default(0);
             $table->string('content');
             $table->timestamps();
         });
-        Schema::create('comments', function (Blueprint $table) {
+        Schema::create('comments', function(Blueprint $table) {
             $table->id();
             $table->morphs('commentable');
             $table->string('content');
             $table->tinyInteger('status')->default(0);
             $table->timestamps();
         });
-        Schema::create('countries', function (Blueprint $table) {
+        Schema::create('countries', function(Blueprint $table) {
             $table->id();
             $table->string('name')->default('');
             $table->timestamps();
         });
-        Schema::create('images', function (Blueprint $table) {
+        Schema::create('images', function(Blueprint $table) {
             $table->id();
             $table->string('url')->default('');
             $table->morphs('imageable');
             $table->timestamps();
         });
-        Schema::create('phones', function (Blueprint $table) {
+        Schema::create('phones', function(Blueprint $table) {
             $table->id();
             $table->bigInteger('user_id')->default(0);
             $table->string('phone_number')->default('');
             $table->timestamps();
         });
-        Schema::create('roles', function (Blueprint $table) {
+        Schema::create('roles', function(Blueprint $table) {
             $table->id();
             $table->string('name');
             $table->timestamps();
         });
-        Schema::create('role_user', function (Blueprint $table) {
+        Schema::create('role_user', function(Blueprint $table) {
             $table->id();
             $table->bigInteger('user_id')->default(0);
             $table->bigInteger('role_id')->default(0);
             $table->timestamps();
         });
-        Schema::create('suppliers', function (Blueprint $table) {
+        Schema::create('suppliers', function(Blueprint $table) {
             $table->id();
             $table->string('name')->default('');
             $table->timestamps();
         });
-        Schema::create('tags', function (Blueprint $table) {
+        Schema::create('tags', function(Blueprint $table) {
             $table->id();
             $table->string('name')->default('');
             $table->timestamps();
         });
-        Schema::create('taggables', function (Blueprint $table) {
+        Schema::create('taggables', function(Blueprint $table) {
             $table->id();
             $table->bigInteger('tag_id')->default(0);
             $table->morphs('taggable');
             $table->timestamps();
         });
-        Schema::create('users', function (Blueprint $table) {
+        Schema::create('users', function(Blueprint $table) {
             $table->id();
             $table->string('username')->default('');
             $table->tinyInteger('age')->default(0);
@@ -77,12 +77,12 @@ 
             $table->bigInteger('supplier_id')->default(0);
             $table->timestamps();
         });
-        Schema::create('videos', function (Blueprint $table) {
+        Schema::create('videos', function(Blueprint $table) {
             $table->id();
             $table->string('name')->default('');
             $table->timestamps();
         });
-        Schema::create('posts', function (Blueprint $table) {
+        Schema::create('posts', function(Blueprint $table) {
             $table->id();
             $table->bigInteger('user_id')->default(0);
             $table->string('title')->default('');

src/Database/Eloquent/RelationMixin.php

Spacing +10 added lines, -10 removed lines

@@ -20,11 +20,11 @@ 
 {
     public function getRelationExistenceInQuery(): Closure
     {
-        return function (Builder $query, Builder $parentQuery, $columns = ['*']): Builder {
-            $relation = function (Builder $query, Builder $parentQuery, $columns = ['*']): Builder {
+        return function(Builder $query, Builder $parentQuery, $columns = [ '*' ]): Builder {
+            $relation = function(Builder $query, Builder $parentQuery, $columns = [ '*' ]): Builder {
                 return $query->select($columns);
             };
-            $belongsTo = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
+            $belongsTo = function(Builder $query, Builder $parentQuery) use ($relation): Builder {
                 $columns = $query->qualifyColumn($this->ownerKey);
 
                 $relationQuery = $relation($query, $parentQuery, $columns);
@@ -39,7 +39,7 @@ 
 
                 return $relationQuery;
             };
-            $belongsToMany = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
+            $belongsToMany = function(Builder $query, Builder $parentQuery) use ($relation): Builder {
                 $columns = $this->getExistenceCompareKey();
                 if ($parentQuery->getQuery()->from == $query->getQuery()->from) {
                     $query->select($columns);
@@ -53,7 +53,7 @@ 
 
                 return $relation($query, $parentQuery, $columns);
             };
-            $hasOneOrMany = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
+            $hasOneOrMany = function(Builder $query, Builder $parentQuery) use ($relation): Builder {
                 $columns = $this->getExistenceCompareKey();
                 if ($query->getQuery()->from == $parentQuery->getQuery()->from) {
                     $query->from($query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash());
@@ -63,33 +63,33 @@ 
 
                 return $relation($query, $parentQuery, $columns);
             };
-            $hasOne = function (Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
+            $hasOne = function(Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
                 if ($this->isOneOfMany()) {
                     $this->mergeOneOfManyJoinsTo($query);
                 }
 
                 return $hasOneOrMany($query, $parentQuery);
             };
-            $morphOneOrMany = function (Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
+            $morphOneOrMany = function(Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
                 return $hasOneOrMany($query, $parentQuery)->where(
                     $query->qualifyColumn($this->getMorphType()),
                     $this->morphClass
                 );
             };
-            $morphOne = function (Builder $query, Builder $parentQuery) use ($morphOneOrMany): Builder {
+            $morphOne = function(Builder $query, Builder $parentQuery) use ($morphOneOrMany): Builder {
                 if ($this->isOneOfMany()) {
                     $this->mergeOneOfManyJoinsTo($query);
                 }
 
                 return $morphOneOrMany($query, $parentQuery);
             };
-            $morphToMany = function (Builder $query, Builder $parentQuery) use ($belongsToMany): Builder {
+            $morphToMany = function(Builder $query, Builder $parentQuery) use ($belongsToMany): Builder {
                 return $belongsToMany($query, $parentQuery)->where(
                     $this->qualifyPivotColumn($this->morphType),
                     $this->morphClass
                 );
             };
-            $hasManyThrough = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
+            $hasManyThrough = function(Builder $query, Builder $parentQuery) use ($relation): Builder {
                 $columns = $this->getQualifiedFirstKeyName();
                 if ($parentQuery->getQuery()->from === $query->getQuery()->from) {
                     $query->from($query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash());

src/Database/Eloquent/BuilderMixin.php

Spacing +34 added lines, -34 removed lines

@@ -17,7 +17,7 @@ 
      */
     public function hasIn(): Closure
     {
-        return function ($relation, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null): Builder {
+        return function($relation, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null): Builder {
             /** @var Builder $this */
             if (is_string($relation)) {
                 if (str_contains($relation, '.')) {
@@ -28,7 +28,7 @@ 
             }
 
             if ($relation instanceof MorphTo) {
-                return $this->hasMorphIn($relation, ['*'], $operator, $count, $boolean, $callback);
+                return $this->hasMorphIn($relation, [ '*' ], $operator, $count, $boolean, $callback);
             }
 
             // If we only need to check for the existence of the relation, then we can optimize
@@ -69,7 +69,7 @@ 
      */
     protected function hasInNested(): Closure
     {
-        return function ($relations, $operator = '>=', $count = 1, $boolean = 'and', $callback = null): Builder {
+        return function($relations, $operator = '>=', $count = 1, $boolean = 'and', $callback = null): Builder {
             /** @var Builder $this */
             $relations = explode('.', $relations);
 
@@ -80,7 +80,7 @@ 
                 $count = 1;
             }
 
-            $closure = function ($q) use (&$closure, &$relations, $operator, $count, $callback) {
+            $closure = function($q) use (&$closure, &$relations, $operator, $count, $callback) {
                 // In order to nest "hasIn", we need to add count relation constraints on the
                 // callback Closure. We'll do this by simply passing the Closure its own
                 // reference to itself so it calls itself recursively on each segment.
@@ -100,7 +100,7 @@ 
      */
     public function orHasIn(): Closure
     {
-        return function ($relation, $operator = '>=', $count = 1): Builder {
+        return function($relation, $operator = '>=', $count = 1): Builder {
             /** @var Builder $this */
             return $this->hasIn($relation, $operator, $count, 'or');
         };
@@ -113,7 +113,7 @@ 
      */
     public function doesntHaveIn(): Closure
     {
-        return function ($relation, $boolean = 'and', Closure $callback = null): Builder {
+        return function($relation, $boolean = 'and', Closure $callback = null): Builder {
             /** @var Builder $this */
             return $this->hasIn($relation, '<', 1, $boolean, $callback);
         };
@@ -126,7 +126,7 @@ 
      */
     public function orDoesntHaveIn(): Closure
     {
-        return function ($relation): Builder {
+        return function($relation): Builder {
             /** @var Builder $this */
             return $this->doesntHaveIn($relation, 'or');
         };
@@ -139,7 +139,7 @@ 
      */
     public function whereHasIn(): Closure
     {
-        return function ($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
+        return function($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
             /** @var Builder $this */
             return $this->hasIn($relation, $operator, $count, 'and', $callback);
         };
@@ -154,10 +154,10 @@ 
      */
     public function withWhereHasIn(): Closure
     {
-        return function ($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
+        return function($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
             /** @var Builder $this */
             return $this->whereHasIn(Str::before($relation, ':'), $callback, $operator, $count)
-                ->with($callback ? [$relation => fn ($query) => $callback($query)] : $relation);
+                ->with($callback ? [ $relation => fn ($query) => $callback($query) ] : $relation);
         };
     }
 
@@ -168,7 +168,7 @@ 
      */
     public function orWhereHasIn(): Closure
     {
-        return function ($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
+        return function($relation, Closure $callback = null, $operator = '>=', $count = 1): Builder {
             /** @var Builder $this */
             return $this->hasIn($relation, $operator, $count, 'or', $callback);
         };
@@ -181,7 +181,7 @@ 
      */
     public function whereDoesntHaveIn(): Closure
     {
-        return function ($relation, Closure $callback = null): Builder {
+        return function($relation, Closure $callback = null): Builder {
             /** @var Builder $this */
             return $this->doesntHaveIn($relation, 'and', $callback);
         };
@@ -194,7 +194,7 @@ 
      */
     public function orWhereDoesntHaveIn(): Closure
     {
-        return function ($relation, Closure $callback = null): Builder {
+        return function($relation, Closure $callback = null): Builder {
             /** @var Builder $this */
             return $this->doesntHaveIn($relation, 'or', $callback);
         };
@@ -207,7 +207,7 @@ 
      */
     public function hasMorphIn(): Closure
     {
-        return function ($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null): Builder {
+        return function($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null): Builder {
             /** @var Builder $this */
             if (is_string($relation)) {
                 $relation = $this->getRelationWithoutConstraints($relation);
@@ -215,7 +215,7 @@ 
 
             $types = (array) $types;
 
-            if ($types === ['*']) {
+            if ($types === [ '*' ]) {
                 $types = $this->model->newModelQuery()->distinct()->pluck($relation->getMorphType())->filter()->all();
             }
 
@@ -223,13 +223,13 @@ 
                 $type = Relation::getMorphedModel($type) ?? $type;
             }
 
-            return $this->where(function ($query) use ($relation, $callback, $operator, $count, $types) {
+            return $this->where(function($query) use ($relation, $callback, $operator, $count, $types) {
                 foreach ($types as $type) {
-                    $query->orWhere(function ($query) use ($relation, $callback, $operator, $count, $type) {
+                    $query->orWhere(function($query) use ($relation, $callback, $operator, $count, $type) {
                         $belongsTo = $this->getBelongsToRelation($relation, $type);
 
                         if ($callback) {
-                            $callback = function ($query) use ($callback, $type) {
+                            $callback = function($query) use ($callback, $type) {
                                 return $callback($query, $type);
                             };
                         }
@@ -249,7 +249,7 @@ 
      */
     public function orHasMorphIn(): Closure
     {
-        return function ($relation, $types, $operator = '>=', $count = 1): Builder {
+        return function($relation, $types, $operator = '>=', $count = 1): Builder {
             /** @var Builder $this */
             return $this->hasMorphIn($relation, $types, $operator, $count, 'or');
         };
@@ -262,7 +262,7 @@ 
      */
     public function doesntHaveMorphIn(): Closure
     {
-        return function ($relation, $types, $boolean = 'and', Closure $callback = null): Builder {
+        return function($relation, $types, $boolean = 'and', Closure $callback = null): Builder {
             /** @var Builder $this */
             return $this->hasMorphIn($relation, $types, '<', 1, $boolean, $callback);
         };
@@ -275,7 +275,7 @@ 
      */
     public function orDoesntHaveMorphIn(): Closure
     {
-        return function ($relation, $types): Builder {
+        return function($relation, $types): Builder {
             /** @var Builder $this */
             return $this->doesntHaveMorphIn($relation, $types, 'or');
         };
@@ -288,7 +288,7 @@ 
      */
     public function whereHasMorphIn(): Closure
     {
-        return function ($relation, $types, Closure $callback = null, $operator = '>=', $count = 1): Builder {
+        return function($relation, $types, Closure $callback = null, $operator = '>=', $count = 1): Builder {
             /** @var Builder $this */
             return $this->hasMorphIn($relation, $types, $operator, $count, 'and', $callback);
         };
@@ -301,7 +301,7 @@ 
      */
     public function orWhereHasMorphIn(): Closure
     {
-        return function ($relation, $types, Closure $callback = null, $operator = '>=', $count = 1): Builder {
+        return function($relation, $types, Closure $callback = null, $operator = '>=', $count = 1): Builder {
             /** @var Builder $this */
             return $this->hasMorphIn($relation, $types, $operator, $count, 'or', $callback);
         };
@@ -314,7 +314,7 @@ 
      */
     public function whereDoesntHaveMorphIn(): Closure
     {
-        return function ($relation, $types, Closure $callback = null): Builder {
+        return function($relation, $types, Closure $callback = null): Builder {
             /** @var Builder $this */
             return $this->doesntHaveMorphIn($relation, $types, 'and', $callback);
         };
@@ -327,7 +327,7 @@ 
      */
     public function orWhereDoesntHaveMorphIn(): Closure
     {
-        return function ($relation, $types, Closure $callback = null): Builder {
+        return function($relation, $types, Closure $callback = null): Builder {
             /** @var Builder $this */
             return $this->doesntHaveMorphIn($relation, $types, 'or', $callback);
         };
@@ -340,8 +340,8 @@ 
      */
     public function whereRelationIn(): Closure
     {
-        return function ($relation, $column, $operator = null, $value = null): Builder {
-            return $this->whereHasIn($relation, function ($query) use ($column, $operator, $value) {
+        return function($relation, $column, $operator = null, $value = null): Builder {
+            return $this->whereHasIn($relation, function($query) use ($column, $operator, $value) {
                 if ($column instanceof Closure) {
                     $column($query);
                 } else {
@@ -358,8 +358,8 @@ 
      */
     public function orWhereRelationIn(): Closure
     {
-        return function ($relation, $column, $operator = null, $value = null): Builder {
-            return $this->orWhereHasIn($relation, function ($query) use ($column, $operator, $value) {
+        return function($relation, $column, $operator = null, $value = null): Builder {
+            return $this->orWhereHasIn($relation, function($query) use ($column, $operator, $value) {
                 if ($column instanceof Closure) {
                     $column($query);
                 } else {
@@ -376,8 +376,8 @@ 
      */
     public function whereMorphRelationIn(): Closure
     {
-        return function ($relation, $types, $column, $operator = null, $value = null): Builder {
-            return $this->whereHasMorphIn($relation, $types, function ($query) use ($column, $operator, $value) {
+        return function($relation, $types, $column, $operator = null, $value = null): Builder {
+            return $this->whereHasMorphIn($relation, $types, function($query) use ($column, $operator, $value) {
                 $query->where($column, $operator, $value);
             });
         };
@@ -390,8 +390,8 @@ 
      */
     public function orWhereMorphRelationIn(): Closure
     {
-        return function ($relation, $types, $column, $operator = null, $value = null): Builder {
-            return $this->orWhereHasMorphIn($relation, $types, function ($query) use ($column, $operator, $value) {
+        return function($relation, $types, $column, $operator = null, $value = null): Builder {
+            return $this->orWhereHasMorphIn($relation, $types, function($query) use ($column, $operator, $value) {
                 $query->where($column, $operator, $value);
             });
         };
@@ -404,7 +404,7 @@ 
      */
     protected function addHasInWhere(): Closure
     {
-        return function (Builder $hasInQuery, Relation $relation, $operator, $count, $boolean): Builder {
+        return function(Builder $hasInQuery, Relation $relation, $operator, $count, $boolean): Builder {
             /** @var Builder $this */
             $hasInQuery->mergeConstraintsFrom($relation->getQuery());