Merge branch '10.x'

driesvints · driesvints · commit d73a545b59e2 · 2024-01-01T14:59:10.000+01:00
# Conflicts:
#	CHANGELOG.md
#	src/Illuminate/Foundation/Application.php
diff --git a/src/Illuminate/Auth/Access/Gate.php b/src/Illuminate/Auth/Access/Gate.php
@@ -318,27 +318,27 @@ public function after(callable $callback)
     }
 
     /**
-     * Determine if the given ability should be granted for the current user.
+     * Determine if all of the given abilities should be granted for the current user.
      *
-     * @param  string  $ability
+     * @param  iterable|string  $abilities
      * @param  array|mixed  $arguments
      * @return bool
      */
-    public function allows($ability, $arguments = [])
+    public function allows($abilities, $arguments = [])
     {
-        return $this->check($ability, $arguments);
+        return $this->check($abilities, $arguments);
     }
 
     /**
-     * Determine if the given ability should be denied for the current user.
+     * Determine if any of the given abilities should be denied for the current user.
      *
-     * @param  string  $ability
+     * @param  iterable|string  $abilities
      * @param  array|mixed  $arguments
      * @return bool
      */
-    public function denies($ability, $arguments = [])
+    public function denies($abilities, $arguments = [])
     {
-        return ! $this->allows($ability, $arguments);
+        return ! $this->allows($abilities, $arguments);
     }
 
     /**
diff --git a/src/Illuminate/Collections/Arr.php b/src/Illuminate/Collections/Arr.php
@@ -113,13 +113,13 @@ public static function dot($array, $prepend = '')
 
         foreach ($array as $key => $value) {
             if (is_array($value) && ! empty($value)) {
-                $results[] = static::dot($value, $prepend.$key.'.');
+                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
             } else {
-                $results[] = [$prepend.$key => $value];
+                $results[$prepend.$key] = $value;
             }
         }
 
-        return array_merge(...$results);
+        return $results;
     }
 
     /**
diff --git a/src/Illuminate/Contracts/Auth/Access/Gate.php b/src/Illuminate/Contracts/Auth/Access/Gate.php
@@ -57,22 +57,22 @@ public function before(callable $callback);
     public function after(callable $callback);
 
     /**
-     * Determine if the given ability should be granted for the current user.
+     * Determine if all of the given abilities should be granted for the current user.
      *
-     * @param  string  $ability
+     * @param  iterable|string  $abilities
      * @param  array|mixed  $arguments
      * @return bool
      */
-    public function allows($ability, $arguments = []);
+    public function allows($abilities, $arguments = []);
 
     /**
-     * Determine if the given ability should be denied for the current user.
+     * Determine if any of the given abilities should be denied for the current user.
      *
-     * @param  string  $ability
+     * @param  iterable|string  $abilities
      * @param  array|mixed  $arguments
      * @return bool
      */
-    public function denies($ability, $arguments = []);
+    public function denies($abilities, $arguments = []);
 
     /**
      * Determine if all of the given abilities should be granted for the current user.
diff --git a/src/Illuminate/Database/Eloquent/Concerns/HasAttributes.php b/src/Illuminate/Database/Eloquent/Concerns/HasAttributes.php
@@ -2157,7 +2157,7 @@ public function originalIsEquivalent($key)
         }
 
         return is_numeric($attribute) && is_numeric($original)
-            && strcmp((string) $attribute, (string) $original) === 0;
+            && BigDecimal::of($attribute)->isEqualTo($original);
     }
 
     /**
@@ -2182,6 +2182,13 @@ protected function transformModelValue($key, $value)
         // an appropriate native PHP type dependent upon the associated value
         // given with the key in the pair. Dayle made this comment line up.
         if ($this->hasCast($key)) {
+            if (static::preventsAccessingMissingAttributes() &&
+                ! array_key_exists($key, $this->attributes) &&
+                ($this->isEnumCastable($key) ||
+                 in_array($this->getCastType($key), static::$primitiveCastTypes))) {
+                $this->throwMissingAttributeExceptionIfApplicable($key);
+            }
+
             return $this->castAttribute($key, $value);
         }
 
diff --git a/src/Illuminate/Database/Schema/Grammars/MySqlGrammar.php b/src/Illuminate/Database/Schema/Grammars/MySqlGrammar.php
@@ -88,7 +88,7 @@ public function compileTables($database)
         return sprintf(
             'select table_name as `name`, (data_length + index_length) as `size`, '
             .'table_comment as `comment`, engine as `engine`, table_collation as `collation` '
-            ."from information_schema.tables where table_schema = %s and table_type = 'BASE TABLE' "
+            ."from information_schema.tables where table_schema = %s and table_type in ('BASE TABLE', 'SYSTEM VERSIONED') "
             .'order by table_name',
             $this->quoteString($database)
         );
diff --git a/src/Illuminate/Session/Store.php b/src/Illuminate/Session/Store.php
@@ -245,6 +245,17 @@ public function only(array $keys)
         return Arr::only($this->attributes, $keys);
     }
 
+    /**
+     * Get all the session data except for a specified array of items.
+     *
+     * @param  array  $keys
+     * @return array
+     */
+    public function except(array $keys)
+    {
+        return Arr::except($this->attributes, $keys);
+    }
+
     /**
      * Checks if a key exists.
      *
diff --git a/src/Illuminate/Support/Facades/Gate.php b/src/Illuminate/Support/Facades/Gate.php
@@ -13,8 +13,8 @@
  * @method static \Illuminate\Auth\Access\Gate policy(string $class, string $policy)
  * @method static \Illuminate\Auth\Access\Gate before(callable $callback)
  * @method static \Illuminate\Auth\Access\Gate after(callable $callback)
- * @method static bool allows(string $ability, array|mixed $arguments = [])
- * @method static bool denies(string $ability, array|mixed $arguments = [])
+ * @method static bool allows(iterable|string $abilities, array|mixed $arguments = [])
+ * @method static bool denies(iterable|string $abilities, array|mixed $arguments = [])
  * @method static bool check(iterable|string $abilities, array|mixed $arguments = [])
  * @method static bool any(iterable|string $abilities, array|mixed $arguments = [])
  * @method static bool none(iterable|string $abilities, array|mixed $arguments = [])
diff --git a/src/Illuminate/Support/Facades/Session.php b/src/Illuminate/Support/Facades/Session.php
@@ -21,6 +21,7 @@
  * @method static void ageFlashData()
  * @method static array all()
  * @method static array only(array $keys)
+ * @method static array except(array $keys)
  * @method static bool exists(string|array $key)
  * @method static bool missing(string|array $key)
  * @method static bool has(string|array $key)
diff --git a/src/Illuminate/Support/Number.php b/src/Illuminate/Support/Number.php
@@ -208,6 +208,19 @@ protected static function summarize(int|float $number, int $precision = 0, ?int
         return trim(sprintf('%s%s', static::format($number, $precision, $maxPrecision), $units[$displayExponent] ?? ''));
     }
 
+    /**
+     * Clamp the given number between the given minimum and maximum.
+     *
+     * @param  int|float  $number
+     * @param  int|float  $min
+     * @param  int|float  $max
+     * @return int|float
+     */
+    public static function clamp(int|float $number, int|float $min, int|float $max)
+    {
+        return min(max($number, $min), $max);
+    }
+
     /**
      * Execute the given callback using the given locale.
      *
diff --git a/tests/Auth/AuthAccessGateTest.php b/tests/Auth/AuthAccessGateTest.php
@@ -326,6 +326,47 @@ public function testAfterCallbacksDoNotOverrideEachOther()
         $this->assertTrue($gate->denies('deny'));
     }
 
+    public function testArrayAbilitiesInAllows()
+    {
+        $gate = $this->getBasicGate();
+
+        $gate->define('allow_1', function ($user) {
+            return true;
+        });
+        $gate->define('allow_2', function ($user) {
+            return true;
+        });
+        $gate->define('deny', function ($user) {
+            return false;
+        });
+
+        $this->assertTrue($gate->allows(['allow_1']));
+        $this->assertTrue($gate->allows(['allow_1', 'allow_2']));
+        $this->assertFalse($gate->allows(['allow_1', 'allow_2', 'deny']));
+        $this->assertFalse($gate->allows(['deny', 'allow_1', 'allow_2']));
+    }
+
+    public function testArrayAbilitiesInDenies()
+    {
+        $gate = $this->getBasicGate();
+
+        $gate->define('deny_1', function ($user) {
+            return false;
+        });
+        $gate->define('deny_2', function ($user) {
+            return false;
+        });
+        $gate->define('allow', function ($user) {
+            return true;
+        });
+
+        $this->assertTrue($gate->denies(['deny_1']));
+        $this->assertTrue($gate->denies(['deny_1', 'deny_2']));
+        $this->assertTrue($gate->denies(['deny_1', 'allow']));
+        $this->assertTrue($gate->denies(['allow', 'deny_1']));
+        $this->assertFalse($gate->denies(['allow']));
+    }
+
     public function testCurrentUserThatIsOnGateAlwaysInjectedIntoClosureCallbacks()
     {
         $gate = $this->getBasicGate();
diff --git a/tests/Database/DatabaseEloquentModelTest.php b/tests/Database/DatabaseEloquentModelTest.php
@@ -7,6 +7,8 @@
 use DateTimeInterface;
 use Exception;
 use Foo\Bar\EloquentModelNamespacedStub;
+use Illuminate\Contracts\Database\Eloquent\Castable;
+use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
 use Illuminate\Contracts\Database\Eloquent\CastsInboundAttributes;
 use Illuminate\Contracts\Encryption\Encrypter;
 use Illuminate\Contracts\Events\Dispatcher;
@@ -22,6 +24,7 @@
 use Illuminate\Database\Eloquent\Casts\AsEnumArrayObject;
 use Illuminate\Database\Eloquent\Casts\AsEnumCollection;
 use Illuminate\Database\Eloquent\Casts\AsStringable;
+use Illuminate\Database\Eloquent\Casts\Attribute;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\Eloquent\Concerns\HasUlids;
 use Illuminate\Database\Eloquent\Concerns\HasUuids;
@@ -2701,6 +2704,45 @@ public function testThrowsWhenAccessingMissingAttributes()
         }
     }
 
+    public function testThrowsWhenAccessingMissingAttributesWhichArePrimitiveCasts()
+    {
+        $originalMode = Model::preventsAccessingMissingAttributes();
+        Model::preventAccessingMissingAttributes();
+
+        $model = new EloquentModelWithPrimitiveCasts(['id' => 1]);
+        $model->exists = true;
+
+        $exceptionCount = 0;
+        $primitiveCasts = EloquentModelWithPrimitiveCasts::makePrimitiveCastsArray();
+        try {
+            try {
+                $this->assertEquals(null, $model->backed_enum);
+            } catch (MissingAttributeException) {
+                $exceptionCount++;
+            }
+
+            foreach ($primitiveCasts as $key => $type) {
+                try {
+                    $v = $model->{$key};
+                } catch (MissingAttributeException) {
+                    $exceptionCount++;
+                }
+            }
+
+            $this->assertInstanceOf(Address::class, $model->address);
+
+            $this->assertEquals(1, $model->id);
+            $this->assertEquals('ok', $model->this_is_fine);
+            $this->assertEquals('ok', $model->this_is_also_fine);
+
+            // Primitive castables, enum castable
+            $expectedExceptionCount = count($primitiveCasts) + 1;
+            $this->assertEquals($expectedExceptionCount, $exceptionCount);
+        } finally {
+            Model::preventAccessingMissingAttributes($originalMode);
+        }
+    }
+
     public function testUsesOverriddenHandlerWhenAccessingMissingAttributes()
     {
         $originalMode = Model::preventsAccessingMissingAttributes();
@@ -3526,3 +3568,71 @@ class CustomCollection extends BaseCollection
 {
     //
 }
+
+class EloquentModelWithPrimitiveCasts extends Model
+{
+    public $fillable = ['id'];
+
+    public $casts = [
+        'backed_enum' => CastableBackedEnum::class,
+        'address' => Address::class,
+    ];
+
+    public static function makePrimitiveCastsArray(): array
+    {
+        $toReturn = [];
+
+        foreach (static::$primitiveCastTypes as $index => $primitiveCastType) {
+            $toReturn['primitive_cast_'.$index] = $primitiveCastType;
+        }
+
+        return $toReturn;
+    }
+
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct($attributes);
+
+        $this->mergeCasts(self::makePrimitiveCastsArray());
+    }
+
+    public function getThisIsFineAttribute($value)
+    {
+        return 'ok';
+    }
+
+    public function thisIsAlsoFine(): Attribute
+    {
+        return Attribute::get(fn () => 'ok');
+    }
+}
+
+enum CastableBackedEnum: string
+{
+    case Value1 = 'value1';
+}
+
+class Address implements Castable
+{
+    public static function castUsing(array $arguments): CastsAttributes
+    {
+        return new class implements CastsAttributes
+        {
+            public function get(Model $model, string $key, mixed $value, array $attributes): Address
+            {
+                return new Address(
+                    $attributes['address_line_one'],
+                    $attributes['address_line_two']
+                );
+            }
+
+            public function set(Model $model, string $key, mixed $value, array $attributes): array
+            {
+                return [
+                    'address_line_one' => $value->lineOne,
+                    'address_line_two' => $value->lineTwo,
+                ];
+            }
+        };
+    }
+}
diff --git a/tests/Database/DatabaseEloquentWithCastsTest.php b/tests/Database/DatabaseEloquentWithCastsTest.php
@@ -3,6 +3,8 @@
 namespace Illuminate\Tests\Database;
 
 use Illuminate\Database\Capsule\Manager as DB;
+use Illuminate\Database\Eloquent\MissingAttributeException;
+use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Model as Eloquent;
 use PHPUnit\Framework\TestCase;
 
@@ -76,6 +78,21 @@ public function testWithCreateOrFirst()
         $this->assertSame($time1->id, $time2->id);
     }
 
+    public function testThrowsExceptionIfCastableAttributeWasNotRetrievedAndPreventMissingAttributesIsEnabled()
+    {
+        Time::create(['time' => now()]);
+        $originalMode = Model::preventsAccessingMissingAttributes();
+        Model::preventAccessingMissingAttributes();
+
+        $this->expectException(MissingAttributeException::class);
+        try {
+            $time = Time::query()->select('id')->first();
+            $this->assertNull($time->time);
+        } finally {
+            Model::preventAccessingMissingAttributes($originalMode);
+        }
+    }
+
     /**
      * Get a database connection instance.
      *
diff --git a/tests/Integration/Console/Scheduling/ScheduleListCommandTest.php b/tests/Integration/Console/Scheduling/ScheduleListCommandTest.php
@@ -18,7 +18,7 @@ protected function setUp(): void
     {
         parent::setUp();
 
-        Carbon::setTestNow(now()->startOfYear());
+        Carbon::setTestNow('2023-1-1');
         ScheduleListCommand::resolveTerminalWidthUsing(fn () => 80);
 
         $this->schedule = $this->app->make(Schedule::class);
diff --git a/tests/Integration/Database/DatabaseEloquentModelCustomCastingTest.php b/tests/Integration/Database/DatabaseEloquentModelCustomCastingTest.php
diff --git a/tests/Integration/Database/SchemaBuilderTest.php b/tests/Integration/Database/SchemaBuilderTest.php
diff --git a/tests/Session/SessionStoreTest.php b/tests/Session/SessionStoreTest.php
diff --git a/tests/Support/SupportArrTest.php b/tests/Support/SupportArrTest.php
diff --git a/tests/Support/SupportNumberTest.php b/tests/Support/SupportNumberTest.php

Original file line number	Diff line number	Diff line change
`@@ -318,27 +318,27 @@ public function after(callable $callback)`
`318`	`318`	`}`
`319`	`319`
`320`	`320`	`/**`
`321`		`- * Determine if the given ability should be granted for the current user.`
	`321`	`+ * Determine if all of the given abilities should be granted for the current user.`
`322`	`322`	`*`
`323`		`- * @param string $ability`
	`323`	`+ * @param iterable\|string $abilities`
`324`	`324`	`* @param array\|mixed $arguments`
`325`	`325`	`* @return bool`
`326`	`326`	`*/`
`327`		`- public function allows($ability, $arguments = [])`
	`327`	`+ public function allows($abilities, $arguments = [])`
`328`	`328`	`{`
`329`		`- return $this->check($ability, $arguments);`
	`329`	`+ return $this->check($abilities, $arguments);`
`330`	`330`	`}`
`331`	`331`
`332`	`332`	`/**`
`333`		`- * Determine if the given ability should be denied for the current user.`
	`333`	`+ * Determine if any of the given abilities should be denied for the current user.`
`334`	`334`	`*`
`335`		`- * @param string $ability`
	`335`	`+ * @param iterable\|string $abilities`
`336`	`336`	`* @param array\|mixed $arguments`
`337`	`337`	`* @return bool`
`338`	`338`	`*/`
`339`		`- public function denies($ability, $arguments = [])`
	`339`	`+ public function denies($abilities, $arguments = [])`
`340`	`340`	`{`
`341`		`- return ! $this->allows($ability, $arguments);`
	`341`	`+ return ! $this->allows($abilities, $arguments);`
`342`	`342`	`}`
`343`	`343`
`344`	`344`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -113,13 +113,13 @@ public static function dot($array, $prepend = '')`
`113`	`113`
`114`	`114`	`foreach ($array as $key => $value) {`
`115`	`115`	`if (is_array($value) && ! empty($value)) {`
`116`		`- $results[] = static::dot($value, $prepend.$key.'.');`
	`116`	`+ $results = array_merge($results, static::dot($value, $prepend.$key.'.'));`
`117`	`117`	`} else {`
`118`		`- $results[] = [$prepend.$key => $value];`
	`118`	`+ $results[$prepend.$key] = $value;`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`
`122`		`- return array_merge(...$results);`
	`122`	`+ return $results;`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -2157,7 +2157,7 @@ public function originalIsEquivalent($key)`
`2157`	`2157`	`}`
`2158`	`2158`
`2159`	`2159`	`return is_numeric($attribute) && is_numeric($original)`
`2160`		`- && strcmp((string) $attribute, (string) $original) === 0;`
	`2160`	`+ && BigDecimal::of($attribute)->isEqualTo($original);`
`2161`	`2161`	`}`
`2162`	`2162`
`2163`	`2163`	`/**`
`@@ -2182,6 +2182,13 @@ protected function transformModelValue($key, $value)`
`2182`	`2182`	`// an appropriate native PHP type dependent upon the associated value`
`2183`	`2183`	`// given with the key in the pair. Dayle made this comment line up.`
`2184`	`2184`	`if ($this->hasCast($key)) {`
	`2185`	`+ if (static::preventsAccessingMissingAttributes() &&`
	`2186`	`+ ! array_key_exists($key, $this->attributes) &&`
	`2187`	`+ ($this->isEnumCastable($key) \|\|`
	`2188`	`+ in_array($this->getCastType($key), static::$primitiveCastTypes))) {`
	`2189`	`+ $this->throwMissingAttributeExceptionIfApplicable($key);`
	`2190`	`+ }`
	`2191`	`+`
`2185`	`2192`	`return $this->castAttribute($key, $value);`
`2186`	`2193`	`}`
`2187`	`2194`