Support Laravel 12

adrianmihaila · adrianmihaila · commit 88c8c9ffc0b5 · 2025-04-28T12:23:57.000+03:00
diff --git a/composer.json b/composer.json
@@ -16,8 +16,8 @@
     ],
     "require": {
         "php" : "^7.2|^8.0",
-        "illuminate/database": "5.*|6.*|7.*|8.*|9.*|10.*|11.*",
-        "illuminate/events": "5.*|6.*|7.*|8.*|9.*|10.*|11.*"
+        "illuminate/database": "5.*|6.*|7.*|8.*|9.*|10.*|11.*|12.*",
+        "illuminate/events": "5.*|6.*|7.*|8.*|9.*|10.*|11.*|12.*"
     },
     "require-dev": {
         "phpunit/phpunit": "^7.5.20|^8.5.28|^9.5",
diff --git a/src/FakeConnection.php b/src/FakeConnection.php
@@ -13,11 +13,11 @@ class FakeConnection extends Connection implements ConnectionInterface
     public static function resolve($connection = null, $db = '', $prefix = '', $config = ['name' => 'arrayDB'])
     {
         $fakeConnection = new FakeConnection(function () {
-            return new FakePDO;
+            return new FakePDO();
         }, $db, $prefix, $config);
 
-        $fakeConnection->setQueryGrammar(new FakeGrammar);
-        
+        $fakeConnection->setQueryGrammar(new FakeGrammar($fakeConnection));
+
         return $fakeConnection;
     }
 
@@ -39,26 +39,27 @@ public function getSchemaGrammar()
     public function query()
     {
         return new FakeQueryBuilder(
-            $this, $this->getQueryGrammar(), $this->getPostProcessor()
+            $this,
+            $this->getQueryGrammar(),
+            $this->getPostProcessor()
         );
     }
 
     protected function getDefaultQueryGrammar()
     {
-        return new FakeGrammar;
+        return new FakeGrammar($this);
     }
 
     public function statement($query, $bindings = [])
     {
         if (is_object($query)) {
             $query = $query->data;
         } else {
-            
         }
         if (FakeSchemaGrammar::$query && is_string($query)) {
             $payload = array_shift(FakeSchemaGrammar::$query);
             $query = [
-                'sql' => $query,
+                'sql'  => $query,
                 'args' => $payload['args'] ?? null,
                 'type' => $payload['type'],
             ];
diff --git a/src/FakeDB.php b/src/FakeDB.php
@@ -63,7 +63,7 @@ public static function createTable($args)
 
     public static function table($table)
     {
-        return new class ($table) {
+        return new class($table) {
             private $table;
 
             public function __construct($table)
@@ -79,7 +79,7 @@ public function addRow($row)
             public function allRows()
             {
                 $rows = [];
-                foreach((FakeDB::$fakeRows[$this->table] ?? []) as $i => $row) {
+                foreach ((FakeDB::$fakeRows[$this->table] ?? []) as $i => $row) {
                     $rows[$i] = $row[$this->table];
                 }
 
@@ -189,12 +189,12 @@ public static function sort($comparisons, Collection $collection)
 
                 $result = 0;
 
-                if (! is_string($prop) && is_callable($prop)) {
+                if (!is_string($prop) && is_callable($prop)) {
                     $result = $prop($a, $b);
                 } else {
                     $values = [data_get($a, $prop), data_get($b, $prop)];
 
-                    if (! $ascending) {
+                    if (!$ascending) {
                         $values = array_reverse($values);
                     }
 
@@ -241,7 +241,7 @@ public static function performSelects($collection, $columns, $selects, $_table)
         return $collection->map(function ($item) use ($columns, $aliases, $_table) {
             if ($columns !== ['*']) {
                 foreach ($columns as $i => $col) {
-                    ! Str::contains($col, '.') && $columns[$i] = $_table.'.'.$col;
+                    !Str::contains($col, '.') && $columns[$i] = $_table.'.'.$col;
                 }
                 $newItem = [];
                 foreach ($columns as $col) {
@@ -362,7 +362,7 @@ public static function isLike($value, $pattern, $item): bool
     {
         $pattern = str_replace('%', '.*', preg_quote($pattern, '/'));
 
-        return (bool) (preg_match("/^{$pattern}$/i", data_get($item, $value) ?? ''));
+        return (bool) preg_match("/^{$pattern}$/i", data_get($item, $value) ?? '');
     }
 
     public static function whereColumn($where, $row)
@@ -436,7 +436,7 @@ public static function lastInsertId()
 
     public static function prefixColumn($column, $mainTable, $joins)
     {
-        if (! Str::contains($column, '.') && ! isset(FakeDB::$fakeRows[$mainTable][0][$mainTable][$column]) && $joins) {
+        if (!Str::contains($column, '.') && !isset(FakeDB::$fakeRows[$mainTable][0][$mainTable][$column]) && $joins) {
             foreach ($joins as $joined) {
                 $table = $joined->table;
                 if (isset(FakeDB::$fakeRows[$table][0][$table][$column])) {
@@ -445,7 +445,7 @@ public static function prefixColumn($column, $mainTable, $joins)
             }
         }
 
-        if (! Str::contains($column, '.')) {
+        if (!Str::contains($column, '.')) {
             $column = $mainTable.'.'.$column;
         }
 
@@ -505,7 +505,7 @@ public static function filter($query, $columns = ['*']): Collection
 
         $orderBy && ($collection = self::sortRows($collection, $orderBy));
 
-        if (! FakeDB::$ignoreWheres) {
+        if (!FakeDB::$ignoreWheres) {
             $collection = FakeDB::applyWheres($query, $collection);
         }
 
@@ -520,11 +520,11 @@ public static function filter($query, $columns = ['*']): Collection
 
     public static function sortRows(Collection $collection, $orderBy)
     {
-        if (! $orderBy) {
+        if (!$orderBy) {
             return $collection;
         }
         if (count($orderBy) === 1 && is_object($orderBy[0]['sql'] ?? '')) {
-            $data = ($orderBy[0]['sql'])->data;
+            $data = $orderBy[0]['sql']->data;
             if ($data['type'] === 'random') {
                 return $collection->shuffle((int) $data['seed']);
             }
@@ -718,15 +718,15 @@ public static function delete($query)
 
     public static function insertGetId(array $values, $table)
     {
-        if (! Arr::isAssoc($values)) {
+        if (!Arr::isAssoc($values)) {
             foreach ($values as $value) {
                 self::insertGetId($value, $table);
             }
 
             return true;
         }
 
-        if (! isset($values['id'])) {
+        if (!isset($values['id'])) {
             $values['id'] = (FakeDB::$tables[$table]['latestRowId'] ?? 0) + 1;
         }
 
diff --git a/src/FakeSchemaGrammar.php b/src/FakeSchemaGrammar.php
@@ -28,7 +28,7 @@ public function compileAdd(Blueprint $blueprint, Fluent $command)
     public function compileChange(Blueprint $blueprint, Fluent $command, Connection $connection)
     {
         self::keepData('change', [$blueprint, $command, $connection]);
-        
+
         return parent::compileChange($blueprint, $command, $connection);
     }
 
@@ -41,17 +41,14 @@ public function compileIndex(Blueprint $blueprint, Fluent $command)
 
     public function compileKey(Blueprint $blueprint, Fluent $command, $type)
     {
-        
     }
 
     public function compileRenameIndex(Blueprint $blueprint, Fluent $command)
     {
-        
     }
 
     public function compileForeign(Blueprint $blueprint, Fluent $command)
     {
-        
     }
 
     public function compileRenameColumn(Blueprint $blueprint, Fluent $command, Connection $connection)
@@ -63,7 +60,6 @@ public function compileRenameColumn(Blueprint $blueprint, Fluent $command, Conne
 
     public function compileUnique(Blueprint $blueprint, Fluent $command)
     {
-        
     }
 
     public function compileRename(Blueprint $blueprint, Fluent $command)
@@ -91,17 +87,25 @@ public function compileColumnListing()
     {
         return $this->stringy([
             'type' => 'columnListing',
-            'sql' => parent::compileColumnListing(),
+            'sql'  => parent::compileColumnListing(),
         ]);
 
         return parent::compileColumnListing();
     }
 
+    public function compileTableListing($schema = null, $schemaQualified = true)
+    {
+        return $this->stringy([
+            'type' => 'getAllTables',
+            'sql'  => parent::compileTableListing($schema, $schemaQualified),
+        ]);
+    }
+
     public function compileGetAllTables()
     {
         return $this->stringy([
             'type' => 'getAllTables',
-            'sql' => parent::compileGetAllTables(),
+            'sql'  => parent::compileGetAllTables(),
         ]);
     }
 
@@ -110,7 +114,7 @@ public function compileColumns($database, $table)
         return $this->stringy([
             'type' => 'columns',
             'args' => ['database' => $database, 'table' => $table],
-            'sql' => parent::compileColumns($database, $table),
+            'sql'  => parent::compileColumns($database, $table),
         ]);
     }
 
@@ -153,14 +157,13 @@ public function compileTableExists()
     {
         return $this->stringy([
             'type' => 'tableExists',
-            'sql' => parent::compileTableExists(),
+            'sql'  => parent::compileTableExists(),
         ]);
     }
 
     private function stringy(array $data)
     {
-        return new class ($data){
-
+        return new class($data) {
             public $data;
 
             public function __construct($data)

Original file line number	Diff line number	Diff line change
`@@ -13,11 +13,11 @@ class FakeConnection extends Connection implements ConnectionInterface`
`13`	`13`	`public static function resolve($connection = null, $db = '', $prefix = '', $config = ['name' => 'arrayDB'])`
`14`	`14`	`{`
`15`	`15`	`$fakeConnection = new FakeConnection(function () {`
`16`		`- return new FakePDO;`
	`16`	`+ return new FakePDO();`
`17`	`17`	`}, $db, $prefix, $config);`
`18`	`18`
`19`		`- $fakeConnection->setQueryGrammar(new FakeGrammar);`
`20`		`-`
	`19`	`+ $fakeConnection->setQueryGrammar(new FakeGrammar($fakeConnection));`
	`20`	`+`
`21`	`21`	`return $fakeConnection;`
`22`	`22`	`}`
`23`	`23`
`@@ -39,26 +39,27 @@ public function getSchemaGrammar()`
`39`	`39`	`public function query()`
`40`	`40`	`{`
`41`	`41`	`return new FakeQueryBuilder(`
`42`		`- $this, $this->getQueryGrammar(), $this->getPostProcessor()`
	`42`	`+ $this,`
	`43`	`+ $this->getQueryGrammar(),`
	`44`	`+ $this->getPostProcessor()`
`43`	`45`	`);`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`protected function getDefaultQueryGrammar()`
`47`	`49`	`{`
`48`		`- return new FakeGrammar;`
	`50`	`+ return new FakeGrammar($this);`
`49`	`51`	`}`
`50`	`52`
`51`	`53`	`public function statement($query, $bindings = [])`
`52`	`54`	`{`
`53`	`55`	`if (is_object($query)) {`
`54`	`56`	`$query = $query->data;`
`55`	`57`	`} else {`
`56`		`-`
`57`	`58`	`}`
`58`	`59`	`if (FakeSchemaGrammar::$query && is_string($query)) {`
`59`	`60`	`$payload = array_shift(FakeSchemaGrammar::$query);`
`60`	`61`	`$query = [`
`61`		`- 'sql' => $query,`
	`62`	`+ 'sql' => $query,`
`62`	`63`	`'args' => $payload['args'] ?? null,`
`63`	`64`	`'type' => $payload['type'],`
`64`	`65`	`];`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public static function createTable($args)`
`63`	`63`
`64`	`64`	`public static function table($table)`
`65`	`65`	`{`
`66`		`- return new class ($table) {`
	`66`	`+ return new class($table) {`
`67`	`67`	`private $table;`
`68`	`68`
`69`	`69`	`public function __construct($table)`
`@@ -79,7 +79,7 @@ public function addRow($row)`
`79`	`79`	`public function allRows()`
`80`	`80`	`{`
`81`	`81`	`$rows = [];`
`82`		`- foreach((FakeDB::$fakeRows[$this->table] ?? []) as $i => $row) {`
	`82`	`+ foreach ((FakeDB::$fakeRows[$this->table] ?? []) as $i => $row) {`
`83`	`83`	`$rows[$i] = $row[$this->table];`
`84`	`84`	`}`
`85`	`85`
`@@ -189,12 +189,12 @@ public static function sort($comparisons, Collection $collection)`
`189`	`189`
`190`	`190`	`$result = 0;`
`191`	`191`
`192`		`- if (! is_string($prop) && is_callable($prop)) {`
	`192`	`+ if (!is_string($prop) && is_callable($prop)) {`
`193`	`193`	`$result = $prop($a, $b);`
`194`	`194`	`} else {`
`195`	`195`	`$values = [data_get($a, $prop), data_get($b, $prop)];`
`196`	`196`
`197`		`- if (! $ascending) {`
	`197`	`+ if (!$ascending) {`
`198`	`198`	`$values = array_reverse($values);`
`199`	`199`	`}`
`200`	`200`
`@@ -241,7 +241,7 @@ public static function performSelects($collection, $columns, $selects, $_table)`
`241`	`241`	`return $collection->map(function ($item) use ($columns, $aliases, $_table) {`
`242`	`242`	`if ($columns !== ['*']) {`
`243`	`243`	`foreach ($columns as $i => $col) {`
`244`		`- ! Str::contains($col, '.') && $columns[$i] = $_table.'.'.$col;`
	`244`	`+ !Str::contains($col, '.') && $columns[$i] = $_table.'.'.$col;`
`245`	`245`	`}`
`246`	`246`	`$newItem = [];`
`247`	`247`	`foreach ($columns as $col) {`
`@@ -362,7 +362,7 @@ public static function isLike($value, $pattern, $item): bool`
`362`	`362`	`{`
`363`	`363`	`$pattern = str_replace('%', '.*', preg_quote($pattern, '/'));`
`364`	`364`
`365`		`- return (bool) (preg_match("/^{$pattern}$/i", data_get($item, $value) ?? ''));`
	`365`	`+ return (bool) preg_match("/^{$pattern}$/i", data_get($item, $value) ?? '');`
`366`	`366`	`}`
`367`	`367`
`368`	`368`	`public static function whereColumn($where, $row)`
`@@ -436,7 +436,7 @@ public static function lastInsertId()`
`436`	`436`
`437`	`437`	`public static function prefixColumn($column, $mainTable, $joins)`
`438`	`438`	`{`
`439`		`- if (! Str::contains($column, '.') && ! isset(FakeDB::$fakeRows[$mainTable][0][$mainTable][$column]) && $joins) {`
	`439`	`+ if (!Str::contains($column, '.') && !isset(FakeDB::$fakeRows[$mainTable][0][$mainTable][$column]) && $joins) {`
`440`	`440`	`foreach ($joins as $joined) {`
`441`	`441`	`$table = $joined->table;`
`442`	`442`	`if (isset(FakeDB::$fakeRows[$table][0][$table][$column])) {`
`@@ -445,7 +445,7 @@ public static function prefixColumn($column, $mainTable, $joins)`
`445`	`445`	`}`
`446`	`446`	`}`
`447`	`447`
`448`		`- if (! Str::contains($column, '.')) {`
	`448`	`+ if (!Str::contains($column, '.')) {`
`449`	`449`	`$column = $mainTable.'.'.$column;`
`450`	`450`	`}`
`451`	`451`
`@@ -505,7 +505,7 @@ public static function filter($query, $columns = ['*']): Collection`
`505`	`505`
`506`	`506`	`$orderBy && ($collection = self::sortRows($collection, $orderBy));`
`507`	`507`
`508`		`- if (! FakeDB::$ignoreWheres) {`
	`508`	`+ if (!FakeDB::$ignoreWheres) {`
`509`	`509`	`$collection = FakeDB::applyWheres($query, $collection);`
`510`	`510`	`}`
`511`	`511`
`@@ -520,11 +520,11 @@ public static function filter($query, $columns = ['*']): Collection`
`520`	`520`
`521`	`521`	`public static function sortRows(Collection $collection, $orderBy)`
`522`	`522`	`{`
`523`		`- if (! $orderBy) {`
	`523`	`+ if (!$orderBy) {`
`524`	`524`	`return $collection;`
`525`	`525`	`}`
`526`	`526`	`if (count($orderBy) === 1 && is_object($orderBy[0]['sql'] ?? '')) {`
`527`		`- $data = ($orderBy[0]['sql'])->data;`
	`527`	`+ $data = $orderBy[0]['sql']->data;`
`528`	`528`	`if ($data['type'] === 'random') {`
`529`	`529`	`return $collection->shuffle((int) $data['seed']);`
`530`	`530`	`}`
`@@ -718,15 +718,15 @@ public static function delete($query)`
`718`	`718`
`719`	`719`	`public static function insertGetId(array $values, $table)`
`720`	`720`	`{`
`721`		`- if (! Arr::isAssoc($values)) {`
	`721`	`+ if (!Arr::isAssoc($values)) {`
`722`	`722`	`foreach ($values as $value) {`
`723`	`723`	`self::insertGetId($value, $table);`
`724`	`724`	`}`
`725`	`725`
`726`	`726`	`return true;`
`727`	`727`	`}`
`728`	`728`
`729`		`- if (! isset($values['id'])) {`
	`729`	`+ if (!isset($values['id'])) {`
`730`	`730`	`$values['id'] = (FakeDB::$tables[$table]['latestRowId'] ?? 0) + 1;`
`731`	`731`	`}`
`732`	`732`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public function compileAdd(Blueprint $blueprint, Fluent $command)`
`28`	`28`	`public function compileChange(Blueprint $blueprint, Fluent $command, Connection $connection)`
`29`	`29`	`{`
`30`	`30`	`self::keepData('change', [$blueprint, $command, $connection]);`
`31`		`-`
	`31`	`+`
`32`	`32`	`return parent::compileChange($blueprint, $command, $connection);`
`33`	`33`	`}`
`34`	`34`
`@@ -41,17 +41,14 @@ public function compileIndex(Blueprint $blueprint, Fluent $command)`
`41`	`41`
`42`	`42`	`public function compileKey(Blueprint $blueprint, Fluent $command, $type)`
`43`	`43`	`{`
`44`		`-`
`45`	`44`	`}`
`46`	`45`
`47`	`46`	`public function compileRenameIndex(Blueprint $blueprint, Fluent $command)`
`48`	`47`	`{`
`49`		`-`
`50`	`48`	`}`
`51`	`49`
`52`	`50`	`public function compileForeign(Blueprint $blueprint, Fluent $command)`
`53`	`51`	`{`
`54`		`-`
`55`	`52`	`}`
`56`	`53`
`57`	`54`	`public function compileRenameColumn(Blueprint $blueprint, Fluent $command, Connection $connection)`
`@@ -63,7 +60,6 @@ public function compileRenameColumn(Blueprint $blueprint, Fluent $command, Conne`
`63`	`60`
`64`	`61`	`public function compileUnique(Blueprint $blueprint, Fluent $command)`
`65`	`62`	`{`
`66`		`-`
`67`	`63`	`}`
`68`	`64`
`69`	`65`	`public function compileRename(Blueprint $blueprint, Fluent $command)`
`@@ -91,17 +87,25 @@ public function compileColumnListing()`
`91`	`87`	`{`
`92`	`88`	`return $this->stringy([`
`93`	`89`	`'type' => 'columnListing',`
`94`		`- 'sql' => parent::compileColumnListing(),`
	`90`	`+ 'sql' => parent::compileColumnListing(),`
`95`	`91`	`]);`
`96`	`92`
`97`	`93`	`return parent::compileColumnListing();`
`98`	`94`	`}`
`99`	`95`
	`96`	`+ public function compileTableListing($schema = null, $schemaQualified = true)`
	`97`	`+ {`
	`98`	`+ return $this->stringy([`
	`99`	`+ 'type' => 'getAllTables',`
	`100`	`+ 'sql' => parent::compileTableListing($schema, $schemaQualified),`
	`101`	`+ ]);`
	`102`	`+ }`
	`103`	`+`
`100`	`104`	`public function compileGetAllTables()`
`101`	`105`	`{`
`102`	`106`	`return $this->stringy([`
`103`	`107`	`'type' => 'getAllTables',`
`104`		`- 'sql' => parent::compileGetAllTables(),`
	`108`	`+ 'sql' => parent::compileGetAllTables(),`
`105`	`109`	`]);`
`106`	`110`	`}`
`107`	`111`
`@@ -110,7 +114,7 @@ public function compileColumns($database, $table)`
`110`	`114`	`return $this->stringy([`
`111`	`115`	`'type' => 'columns',`
`112`	`116`	`'args' => ['database' => $database, 'table' => $table],`
`113`		`- 'sql' => parent::compileColumns($database, $table),`
	`117`	`+ 'sql' => parent::compileColumns($database, $table),`
`114`	`118`	`]);`
`115`	`119`	`}`
`116`	`120`
`@@ -153,14 +157,13 @@ public function compileTableExists()`
`153`	`157`	`{`
`154`	`158`	`return $this->stringy([`
`155`	`159`	`'type' => 'tableExists',`
`156`		`- 'sql' => parent::compileTableExists(),`
	`160`	`+ 'sql' => parent::compileTableExists(),`
`157`	`161`	`]);`
`158`	`162`	`}`
`159`	`163`
`160`	`164`	`private function stringy(array $data)`
`161`	`165`	`{`
`162`		`- return new class ($data){`
`163`		`-`
	`166`	`+ return new class($data) {`
`164`	`167`	`public $data;`
`165`	`168`
`166`	`169`	`public function __construct($data)`