code
stringlengths 31
1.39M
| docstring
stringlengths 23
16.8k
| func_name
stringlengths 1
126
| language
stringclasses 1
value | repo
stringlengths 7
63
| path
stringlengths 7
166
| url
stringlengths 50
220
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
public function definition()
{
return [
'name' => $this->faker->name(),
'email' => $this->faker->unique()->safeEmail(),
'email_verified_at' => now(),
'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
'remember_token' => Str::random(10),
];
} | Define the model's default state.
@return array<string, mixed> | definition | php | larastan/larastan | tests/application/database/factories/UserFactory.php | https://github.com/larastan/larastan/blob/master/tests/application/database/factories/UserFactory.php | MIT |
public function unverified()
{
return $this->state(function (array $attributes) {
return [
'email_verified_at' => null,
];
});
} | Indicate that the model's email address should be unverified.
@return self | unverified | php | larastan/larastan | tests/application/database/factories/UserFactory.php | https://github.com/larastan/larastan/blob/master/tests/application/database/factories/UserFactory.php | MIT |
public function definition()
{
return [
'name' => $this->faker->name(),
'user_id' => User::factory(),
];
} | Define the model's default state.
@return array<string, mixed> | definition | php | larastan/larastan | tests/application/database/factories/Post/PostFactory.php | https://github.com/larastan/larastan/blob/master/tests/application/database/factories/Post/PostFactory.php | MIT |
public static function dataIntegrationTests(): iterable
{
self::getContainer();
yield [__DIR__ . '/data/bug-2074.php'];
yield [__DIR__ . '/data/test-case-extension.php', [34 => ['Call to function method_exists() with $this(TestTestCase) and \'partialMock\' will always evaluate to true.']]];
yield [__DIR__ . '/data/model-builder.php'];
yield [__DIR__ . '/data/model-properties.php'];
yield [__DIR__ . '/data/model-factories.php'];
yield [__DIR__ . '/data/blade-view.php'];
yield [__DIR__ . '/data/helpers.php'];
yield [
__DIR__ . '/data/model-property-builder.php',
[
15 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::firstWhere() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, \'foo\' given.'],
16 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::firstWhere() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, \'id\'|\'unionNotExisting\' given.'],
17 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::where() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, \'foo\' given.'],
19 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::where() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, \'foo\' given.'],
20 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::where() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, \'foo\' given.'],
24 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::where() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, string given.'],
25 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::orWhere() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, \'foo\' given.'],
26 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::orWhere() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, \'foo\' given.'],
27 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::orWhere() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, array{foo: \'foo\'} given.'],
30 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::value() expects Illuminate\Contracts\Database\Query\Expression|model property of App\User, string given.'],
35 => ['Parameter #1 $columns of method Illuminate\Database\Eloquent\Builder<App\User>::first() expects array<int, model property of App\User>|model property of App\User, array<int, string> given.'],
36 => ['Parameter #1 $columns of method Illuminate\Database\Eloquent\Builder<App\User>::first() expects array<int, model property of App\User>|model property of App\User, string given.'],
39 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\User>::where() expects array<int|model property of App\User, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): Illuminate\Database\Eloquent\Builder<App\User>)|(Closure(Illuminate\Database\Eloquent\Builder<App\User>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\User, \'roles.foo\' given.'],
],
];
yield [
__DIR__ . '/data/model-property-model.php',
[
11 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Model::update() expects array<model property of static(ModelPropertyModel\ModelPropertyOnModel), mixed>, array<string, string> given.'],
18 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Model::update() expects array<model property of App\Account|App\User, mixed>, array<string, string> given.'],
25 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Model::update() expects array<model property of App\Account|App\User, mixed>, array<string, string> given.'],
49 => ['Parameter #1 $property of method ModelPropertyModel\ModelPropertyCustomMethods::foo() expects model property of App\User, string given.'],
68 => ['Parameter #1 $property of method ModelPropertyModel\ModelPropertyCustomMethodsInNormalClass::foo() expects model property of App\User, string given.'],
94 => ['Parameter #1 $userModelProperty of function ModelPropertyModel\acceptsUserProperty expects model property of App\User, model property of App\Account given.'],
107 => ['Parameter #1 $accountModelProperty of function ModelPropertyModel\acceptsUserOrAccountProperty expects model property of App\Account|App\User, string given.'],
],
];
yield [
__DIR__ . '/data/model-property-model-factory.php',
[
7 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Factories\Factory<App\User>::createOne() expects array<model property of App\User, mixed>|(callable(array<string, mixed>): array<string, mixed>), array{foo: \'bar\'} given.'],
],
];
yield [
__DIR__ . '/data/model-property-relation.php',
[
4 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\Account>::where() expects array<int|model property of App\Account, mixed>|(Closure(Illuminate\Database\Eloquent\Builder<App\Account>): Illuminate\Database\Eloquent\Builder<App\Account>)|(Closure(Illuminate\Database\Eloquent\Builder<App\Account>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\Account, \'foo\' given.'],
5 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Relations\HasOneOrMany<App\Account,App\User,Illuminate\Database\Eloquent\Collection<int, App\Account>>::create() expects array<model property of App\Account, mixed>, array<string, string> given.'],
6 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Relations\HasOneOrMany<App\Account,App\User,Illuminate\Database\Eloquent\Collection<int, App\Account>>::firstOrNew() expects array<model property of App\Account, mixed>, array<string, string> given.'],
7 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Relations\HasOneOrMany<App\Account,App\User,Illuminate\Database\Eloquent\Collection<int, App\Account>>::firstOrCreate() expects array<model property of App\Account, mixed>, array<string, string> given.'],
8 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Relations\HasOneOrMany<App\Account,App\User,Illuminate\Database\Eloquent\Collection<int, App\Account>>::updateOrCreate() expects array<model property of App\Account, mixed>, array<string, string> given.'],
10 => ['Parameter #1 $column of method Illuminate\Database\Eloquent\Builder<App\Post>::where() expects array<int|model property of App\Post, mixed>|(Closure(App\PostBuilder<App\Post>): App\PostBuilder<App\Post>)|(Closure(App\PostBuilder<App\Post>): void)|Illuminate\Contracts\Database\Query\Expression|model property of App\Post, \'foo\' given.'],
12 => ['Parameter #1 $attributes of method Illuminate\Database\Eloquent\Relations\HasOneOrMany<App\Account,App\User,Illuminate\Database\Eloquent\Collection<int, App\Account>>::createOrFirst() expects array<model property of App\Account, mixed>, array<string, string> given.'],
],
];
yield [
__DIR__ . '/data/model-property-static-call.php',
[
10 => ['Parameter #1 $attributes of static method Illuminate\Database\Eloquent\Builder<App\User>::create() expects array<model property of App\User, mixed>, array<string, string> given.'],
14 => ['Parameter #1 $attributes of static method Illuminate\Database\Eloquent\Builder<App\User>::create() expects array<model property of App\User, mixed>, array<string, string> given.'],
26 => ['Parameter #1 $attributes of static method Illuminate\Database\Eloquent\Builder<ModelPropertyStaticCall\ModelPropertyStaticCallsInClass>::create() expects array<model property of ModelPropertyStaticCall\ModelPropertyStaticCallsInClass, mixed>, array<string, string> given.'],
34 => ['Parameter #1 $attributes of static method Illuminate\Database\Eloquent\Builder<ModelPropertyStaticCall\ModelPropertyStaticCallsInClass>::create() expects array<model property of ModelPropertyStaticCall\ModelPropertyStaticCallsInClass, mixed>, array<string, string> given.'],
],
];
yield [
__DIR__ . '/data/model-property-mutator-and-casting.php',
[
24 => ['Parameter #1 $lineOne of class ModelPropertyMutatorAndCasting\Address constructor expects string, mixed given.'],
25 => ['Parameter #2 $lineTwo of class ModelPropertyMutatorAndCasting\Address constructor expects string, mixed given.'],
],
];
} | @return iterable<array{0: string, 1?: array<int, array<int, string>>}> | dataIntegrationTests | php | larastan/larastan | tests/Integration/IntegrationTest.php | https://github.com/larastan/larastan/blob/master/tests/Integration/IntegrationTest.php | MIT |
public function testIntegration(string $file, array|null $expectedErrors = null): void
{
$errors = $this->runAnalyse($file);
if ($expectedErrors === null) {
$this->assertNoErrors($errors);
} else {
if (count($expectedErrors) > 0) {
$this->assertNotEmpty($errors);
}
$this->assertSameErrorMessages($file, $expectedErrors, $errors);
}
} | @param array<int, array<int, string>>|null $expectedErrors
@dataProvider dataIntegrationTests | testIntegration | php | larastan/larastan | tests/Integration/IntegrationTest.php | https://github.com/larastan/larastan/blob/master/tests/Integration/IntegrationTest.php | MIT |
private function runAnalyse(string $file, array|null $allAnalysedFiles = null): array
{
$file = $this->getFileHelper()->normalizePath($file);
/** @var Analyser $analyser */
$analyser = self::getContainer()->getByType(Analyser::class); // @phpstan-ignore-line
/** @var FileHelper $fileHelper */
$fileHelper = self::getContainer()->getByType(FileHelper::class);
$errors = $analyser->analyse([$file], null, null, true, $allAnalysedFiles)->getErrors(); // @phpstan-ignore-line
foreach ($errors as $error) {
$this->assertSame($fileHelper->normalizePath($file), $error->getFilePath());
}
return $errors;
} | @see https://github.com/phpstan/phpstan-src/blob/c9772621c0bd6eab7e02fdaa03714bea239b372d/tests/PHPStan/Analyser/AnalyserIntegrationTest.php#L604-L622
@see https://github.com/phpstan/phpstan/discussions/6888#discussioncomment-2423613
@param string[]|null $allAnalysedFiles
@return Error[]
@throws Throwable | runAnalyse | php | larastan/larastan | tests/Integration/IntegrationTest.php | https://github.com/larastan/larastan/blob/master/tests/Integration/IntegrationTest.php | MIT |
private function assertSameErrorMessages(string $file, array $expectedErrors, array $errors): void
{
foreach ($errors as $error) {
$errorLine = $error->getLine() ?? 0;
$this->assertArrayHasKey(
$errorLine,
$expectedErrors,
sprintf('File %s has unexpected error "%s" at line %d.', $file, $error->getMessage(), $errorLine),
);
$this->assertContains(
$error->getMessage(),
$expectedErrors[$errorLine],
sprintf("File %s has unexpected error \"%s\" at line %d.\n\nExpected \"%s\"", $file, $error->getMessage(), $errorLine, implode("\n\t", $expectedErrors[$errorLine])),
);
}
} | @param array<int, array<int, string>> $expectedErrors
@param Error[] $errors | assertSameErrorMessages | php | larastan/larastan | tests/Integration/IntegrationTest.php | https://github.com/larastan/larastan/blob/master/tests/Integration/IntegrationTest.php | MIT |
function test(Builder $builder, User $user, string $union): void
{
User::query()->firstWhere('foo', 'bar');
User::query()->firstWhere($union, 'bar');
User::query()->where('foo', 'bar')->get();
$builder->where('foo', 'bar');
$user->where('foo', 'bar');
User::query()->firstWhere(DB::raw('name LIKE \'%john%\''));
User::query()->where(getKey(), '=', 'foo');
User::query()->orWhere('foo', '=', 'foo');
User::query()->orWhere('foo', 'foo');
User::query()->orWhere([
'foo' => 'foo',
]);
User::query()->value('foo');
User::query()->where('propertyDefinedOnlyInAnnotation', 'foo');
User::query()->where('only_available_with_accessor', 'foo');
User::query()->first(['foo', 'bar']);
User::query()->first('foo');
// Joins
User::query()->join('roles', 'users.role_id', '=', 'roles.id')->where('roles.foo', 'admin');
} | @param Builder<User> $builder
@param 'unionNotExisting'|'id' $union | test | php | larastan/larastan | tests/Integration/data/model-property-builder.php | https://github.com/larastan/larastan/blob/master/tests/Integration/data/model-property-builder.php | MIT |
public function foo(string $property): void
{
// Do something with property
} | @phpstan-param model-property<\App\User> $property
@param string $property | foo | php | larastan/larastan | tests/Integration/data/model-property-model.php | https://github.com/larastan/larastan/blob/master/tests/Integration/data/model-property-model.php | MIT |
public function foo(string $property): void
{
// Do something with property
} | @phpstan-param model-property<\App\User> $property
@param string $property | foo | php | larastan/larastan | tests/Integration/data/model-property-model.php | https://github.com/larastan/larastan/blob/master/tests/Integration/data/model-property-model.php | MIT |
function getAccountProperty(string $property): void
{
acceptsUserProperty($property);
} | @param model-property<\App\Account> $property | getAccountProperty | php | larastan/larastan | tests/Integration/data/model-property-model.php | https://github.com/larastan/larastan/blob/master/tests/Integration/data/model-property-model.php | MIT |
public function testContainsClosure(): bool
{
return User::where('id', '>', 1)->get()->contains(function (User $user): bool {
return $user->id === 2;
});
} | Can't analyze the closure as a parameter to contains, so should not throw any error.
@return bool | testContainsClosure | php | larastan/larastan | tests/Rules/data/CorrectCollectionCalls.php | https://github.com/larastan/larastan/blob/master/tests/Rules/data/CorrectCollectionCalls.php | MIT |
public function testContainsArrowFunction(): bool
{
return User::where('id', '>', 1)->get()->contains(fn (User $user): bool => $user->id === 2);
} | Can't analyze the arrow function as a parameter to contains, so should not throw any error.
@return bool | testContainsArrowFunction | php | larastan/larastan | tests/Rules/data/CorrectCollectionCalls.php | https://github.com/larastan/larastan/blob/master/tests/Rules/data/CorrectCollectionCalls.php | MIT |
public function testFirstClosure(): ?User
{
return User::where('id', '>', 1)->get()->first(function (User $user): bool {
return $user->id === 2;
});
} | Can't analyze the closure as a parameter to first, so should not throw any error.
@return User|null | testFirstClosure | php | larastan/larastan | tests/Rules/data/CorrectCollectionCalls.php | https://github.com/larastan/larastan/blob/master/tests/Rules/data/CorrectCollectionCalls.php | MIT |
public function testFirstArrowFunction(): ?User
{
return User::where('id', '>', 1)->get()->first(fn (User $user): bool => $user->id === 2);
} | Can't analyze the arrow function as a parameter to first, so should not throw any error.
@return User|null | testFirstArrowFunction | php | larastan/larastan | tests/Rules/data/CorrectCollectionCalls.php | https://github.com/larastan/larastan/blob/master/tests/Rules/data/CorrectCollectionCalls.php | MIT |
public function newEloquentBuilder($query): FooBuilder
{
return new FooBuilder($query);
} | @param \Illuminate\Database\Query\Builder $query
@return FooBuilder | newEloquentBuilder | php | larastan/larastan | tests/Rules/data/CorrectCollectionCalls.php | https://github.com/larastan/larastan/blob/master/tests/Rules/data/CorrectCollectionCalls.php | MIT |
public function testUnion(
callable $types,
string $expectedTypeClass,
string $expectedTypeDescription,
): void {
$types = $types(static::getContainer());
$actualType = TypeCombinator::union(...$types);
$actualTypeDescription = $actualType->describe(VerbosityLevel::precise());
$this->assertSame(
$expectedTypeDescription,
$actualTypeDescription,
sprintf('union(%s)', implode(', ', array_map(
static fn (Type $type): string => $type->describe(VerbosityLevel::precise()),
$types,
))),
);
$this->assertInstanceOf($expectedTypeClass, $actualType);
} | @param class-string<Type> $expectedTypeClass
@dataProvider dataUnion | testUnion | php | larastan/larastan | tests/Type/GenericModelPropertyTypeTest.php | https://github.com/larastan/larastan/blob/master/tests/Type/GenericModelPropertyTypeTest.php | MIT |
public function testUnionInversed(
callable $types,
string $expectedTypeClass,
string $expectedTypeDescription,
): void {
$types = array_reverse($types(static::getContainer()));
$actualType = TypeCombinator::union(...$types);
$actualTypeDescription = $actualType->describe(VerbosityLevel::precise());
$this->assertSame(
$expectedTypeDescription,
$actualTypeDescription,
sprintf('union(%s)', implode(', ', array_map(
static fn (Type $type): string => $type->describe(VerbosityLevel::precise()),
$types,
))),
);
$this->assertInstanceOf($expectedTypeClass, $actualType);
} | @param class-string<Type> $expectedTypeClass
@dataProvider dataUnion | testUnionInversed | php | larastan/larastan | tests/Type/GenericModelPropertyTypeTest.php | https://github.com/larastan/larastan/blob/master/tests/Type/GenericModelPropertyTypeTest.php | MIT |
public static function dataUnion(): iterable
{
yield [
static fn ($container) => [
new GenericModelPropertyType(new ObjectType(User::class), $container->getByType(ModelPropertyHelper::class)),
new GenericModelPropertyType(new ObjectType(Account::class), $container->getByType(ModelPropertyHelper::class)),
],
UnionType::class,
'model property of App\Account|model property of App\User',
];
yield [
static fn ($container) => [
new GenericModelPropertyType(new ObjectType(User::class), $container->getByType(ModelPropertyHelper::class)),
new StringType(),
],
StringType::class,
'string',
];
yield [
static fn ($container) => [
new GenericModelPropertyType(new ObjectType(User::class), $container->getByType(ModelPropertyHelper::class)),
new ConstantStringType('email'),
],
GenericModelPropertyType::class,
'model property of App\User',
];
} | @return iterable<array{callable(mixed): Type[], class-string<Type>, string}> | dataUnion | php | larastan/larastan | tests/Type/GenericModelPropertyTypeTest.php | https://github.com/larastan/larastan/blob/master/tests/Type/GenericModelPropertyTypeTest.php | MIT |
public function testIntersect(
callable $types,
string $expectedTypeClass,
string $expectedTypeDescription,
): void {
$types = $types(static::getContainer());
$actualType = TypeCombinator::intersect(...$types);
$actualTypeDescription = $actualType->describe(VerbosityLevel::precise());
$this->assertSame($expectedTypeDescription, $actualTypeDescription);
$this->assertInstanceOf($expectedTypeClass, $actualType);
} | @param class-string<Type> $expectedTypeClass
@dataProvider dataIntersect | testIntersect | php | larastan/larastan | tests/Type/GenericModelPropertyTypeTest.php | https://github.com/larastan/larastan/blob/master/tests/Type/GenericModelPropertyTypeTest.php | MIT |
public function testIntersectInversed(
callable $types,
string $expectedTypeClass,
string $expectedTypeDescription,
): void {
$actualType = TypeCombinator::intersect(...array_reverse($types(static::getContainer())));
$actualTypeDescription = $actualType->describe(VerbosityLevel::precise());
$this->assertSame($expectedTypeDescription, $actualTypeDescription);
$this->assertInstanceOf($expectedTypeClass, $actualType);
} | @param class-string<Type> $expectedTypeClass
@dataProvider dataIntersect | testIntersectInversed | php | larastan/larastan | tests/Type/GenericModelPropertyTypeTest.php | https://github.com/larastan/larastan/blob/master/tests/Type/GenericModelPropertyTypeTest.php | MIT |
public static function dataIntersect(): iterable
{
yield [
static fn ($container) => [
new GenericModelPropertyType(new ObjectType(User::class), $container->getByType(ModelPropertyHelper::class)),
new GenericModelPropertyType(new ObjectType(Account::class), $container->getByType(ModelPropertyHelper::class)),
],
NeverType::class,
'*NEVER*',
];
yield [
static fn ($container) => [
new GenericModelPropertyType(new ObjectType(User::class), $container->getByType(ModelPropertyHelper::class)),
new StringType(),
],
GenericModelPropertyType::class,
'model property of App\User',
];
yield [
static fn ($container) => [
new GenericModelPropertyType(new ObjectType(User::class), $container->getByType(ModelPropertyHelper::class)),
new ConstantStringType('email'),
],
ConstantStringType::class,
"'email'",
];
} | @return iterable<array{callable(mixed): Type[], class-string<Type>, string}> | dataIntersect | php | larastan/larastan | tests/Type/GenericModelPropertyTypeTest.php | https://github.com/larastan/larastan/blob/master/tests/Type/GenericModelPropertyTypeTest.php | MIT |
function test(Collection $collection): void
{
assertType('Bug2073\ModelCollection<int, Bug2073\User<int>>', ModelCollection::make($collection));
assertType('Bug2073\ModelCollection<int, Bug2073\User<int>>', ModelCollection::make($collection->all()));
} | @param Collection<int, User<int>> $collection
@return void | test | php | larastan/larastan | tests/Type/data/bug-2073.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/bug-2073.php | MIT |
public function newCollection(array $models = []): ModelCollection
{
return new ModelCollection($models);
} | @param User[] $models
@return ModelCollection<int, User> | newCollection | php | larastan/larastan | tests/Type/data/bug-2073.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/bug-2073.php | MIT |
function test(User $user, SupportCollection $users, SupportCollection $mixedCollection): void
{
assertType("Illuminate\Support\Collection<(int|string), mixed~(0|0.0|''|'0'|array{}|false|null)>", collect()->filter());
assertType('Illuminate\Support\Collection<int, non-falsy-string>', collect(['foo', null, '', 'bar', null])->filter());
assertType('Illuminate\Support\Collection<int, int<3, max>>', collect([1, 2, 3, 4, 5, 6])->filter(function (int $value) {
return $value > 2;
}));
assertType('Illuminate\Support\Collection<int, int<3, max>>', collect([1, 2, 3, 4, 5, 6])->filter(fn (int $value) => $value > 2));
assertType("Illuminate\Database\Eloquent\Collection<int, App\User>", $users->filter(function (User $user): bool {
return ! $user->blocked;
}));
assertType("Illuminate\Database\Eloquent\Collection<int, App\User>", $users->filter(fn (User $user) => ! $user->blocked));
assertType(
'Illuminate\Support\Collection<int, App\Account>',
collect($users->all())
->map(function (User $attachment): ?Account {
return convertToAccount($attachment);
})
->filter()
);
$accounts = $user->accounts()->active()->get();
assertType('App\AccountCollection<int, App\Account>', $accounts);
assertType('App\AccountCollection<int, App\Account>', $accounts->filter(function ($account) {
return \CollectionStubs\dummyFilter($account);
}));
$accounts->filter(function ($account) {
return dummyFilter($account);
})
->map(function ($account) {
assertType('App\Account', $account);
});
assertType("Illuminate\Support\Collection<(int|string), mixed~(0|0.0|''|'0'|array{}|false|null)>", $mixedCollection->pluck('foo')->filter());
} | @param EloquentCollection<int, User> $users
@param SupportCollection<array-key, mixed> $mixedCollection | test | php | larastan/larastan | tests/Type/data/collection-filter.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/collection-filter.php | MIT |
function test(
EloquentCollection $collection,
TransactionCollection $customEloquentCollection,
UserCollection $secondCustomEloquentCollection,
): void {
assertType('Illuminate\Database\Eloquent\Collection<int<0, 1>, Illuminate\Database\Eloquent\Collection<int, App\User>>', $collection->partition('foo'));
assertType('App\TransactionCollection<int<0, 1>, App\TransactionCollection<int, App\Transaction>>', $customEloquentCollection->partition('foo'));
assertType('App\UserCollection', $secondCustomEloquentCollection->partition('foo'));
} | @param EloquentCollection<int, User> $collection
@param TransactionCollection<int, Transaction> $customEloquentCollection | test | php | larastan/larastan | tests/Type/data/collection-generic-static-methods-l11.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/collection-generic-static-methods-l11.php | MIT |
function test(
EloquentCollection $collection,
TransactionCollection $customEloquentCollection,
UserCollection $secondCustomEloquentCollection,
): void {
assertType('Illuminate\Support\Collection<int<0, 1>, Illuminate\Database\Eloquent\Collection<int, App\User>>', $collection->partition('foo'));
assertType('Illuminate\Support\Collection<int<0, 1>, App\TransactionCollection<int, App\Transaction>>', $customEloquentCollection->partition('foo'));
assertType('Illuminate\Support\Collection<int<0, 1>, App\UserCollection>', $secondCustomEloquentCollection->partition('foo'));
} | @param EloquentCollection<int, User> $collection
@param TransactionCollection<int, Transaction> $customEloquentCollection | test | php | larastan/larastan | tests/Type/data/collection-generic-static-methods-l12.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/collection-generic-static-methods-l12.php | MIT |
function test(
EloquentCollection $collection, SupportCollection $items,
TransactionCollection $customEloquentCollection, UserCollection $secondCustomEloquentCollection,
LazyCollection $lazyCollection, User $user,
Enumerable $enumerableIntUsers, Enumerable $enumerableStringUsers
): void {
assertType('Illuminate\Database\Eloquent\Collection<int, int>', EloquentCollection::range(1, 10));
assertType('Illuminate\Support\LazyCollection<int, int>', LazyCollection::range(1, 10));
assertType('Illuminate\Support\Collection<int, mixed>', $collection->collapse());
assertType('Illuminate\Support\Collection<int, mixed>', $items->collapse());
assertType('Illuminate\Database\Eloquent\Collection<int, array<int, App\User|int>>', $collection->crossJoin([1]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->find($items));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->find([1]));
assertType('App\User|null', $collection->find($user));
assertType('App\User|null', $collection->find(1));
assertType('App\User|false', $collection->find(1, false));
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->find($items));
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->find([1]));
assertType('App\Transaction|null', $customEloquentCollection->find($user));
assertType('App\Transaction|null', $customEloquentCollection->find(1));
assertType('App\Transaction|false', $customEloquentCollection->find(1, false));
assertType('App\UserCollection', $secondCustomEloquentCollection->find($items));
assertType('App\UserCollection', $secondCustomEloquentCollection->find([1]));
assertType('App\User|null', $secondCustomEloquentCollection->find($user));
assertType('App\User|null', $secondCustomEloquentCollection->find(1));
assertType('App\User|false', $secondCustomEloquentCollection->find(1, false));
assertType('Illuminate\Support\Collection<int, mixed>', $collection->flatten());
assertType('Illuminate\Support\Collection<int, mixed>', $items->flatten());
assertType('Illuminate\Support\Collection<App\User, int>', $collection->flip());
assertType('Illuminate\Support\Collection<int, string>', $items->flip());
assertType('Illuminate\Database\Eloquent\Collection<(int|string), Illuminate\Database\Eloquent\Collection<int, App\User>>', $collection->groupBy('id'));
assertType('Illuminate\Support\Collection<(int|string), Illuminate\Support\Collection<int, int>>', $items->groupBy('id'));
assertType('Illuminate\Database\Eloquent\Collection<string, App\User>', $collection->keyBy(fn (User $user, int $key): string => $user->email));
assertType('Illuminate\Support\Collection<int, int>', $collection->keys());
assertType('Illuminate\Support\Collection<int, string>', $items->keys());
assertType('Illuminate\Support\Collection<(int|string), mixed>', $collection->pluck(['email']));
assertType('Illuminate\Support\Collection<(int|string), mixed>', $items->pluck('1'));
assertType('Illuminate\Support\Collection<int, int>', $customEloquentCollection->map(fn (Transaction $transaction): int => $transaction->id));
assertType('Illuminate\Support\Collection<int, int>', $secondCustomEloquentCollection->map(fn (User $user): int => $user->id));
assertType('Illuminate\Support\Collection<int, int>', $collection->map(fn (User $user): int => $user->id));
assertType('Illuminate\Support\Collection<string, int>', $items->map(fn (int $value, string $key): int => $value));
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->map(fn (Transaction $transaction): Transaction => $transaction));
assertType('App\UserCollection', $secondCustomEloquentCollection->map(fn (User $user): User => $user));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->map(fn (User $user): User => $user));
assertType('Illuminate\Database\Eloquent\Collection<int, array<int, int>>', $collection->mapToDictionary(fn (User $u) => [$u->id => $u->id]));
assertType('App\TransactionCollection<string, array<int, int>>', $customEloquentCollection->mapToDictionary(fn (Transaction $t) => ['foo'=> $t->id]));
assertType('App\UserCollection', $secondCustomEloquentCollection->mapToDictionary(fn (User $t) => ['foo'=> $t->id]));
assertType('Illuminate\Support\Collection<string, array<int, int>>', $items->mapToDictionary(fn (int $v) => ['foo' => $v]));
assertType('Illuminate\Support\Collection<int, string>', $customEloquentCollection->mapWithKeys(fn (Transaction $transaction): array => [$transaction->id => 'foo']));
assertType('Illuminate\Support\Collection<int, string>', $secondCustomEloquentCollection->mapWithKeys(fn (User $user): array => [$user->id => 'foo']));
assertType('Illuminate\Support\Collection<int, int>', $collection->mapWithKeys(fn (User $user): array => [$user->id => $user->id]));
assertType('Illuminate\Support\Collection<string, int>', $items->mapWithKeys(fn (int $value, string $key): array => ['foo' => $value]));
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->mapWithKeys(fn (Transaction $transaction): array => [$transaction->id => $transaction]));
assertType('App\UserCollection', $secondCustomEloquentCollection->mapWithKeys(fn (User $user): array => [$user->email => $user]));
assertType('Illuminate\Database\Eloquent\Collection<string, App\User>', $collection->mapWithKeys(fn (User $user): array => [$user->name => $user]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User|string>', $collection->mergeRecursive([2 => 'foo']));
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->mergeRecursive([1 => new Transaction()]));
assertType('App\UserCollection', $secondCustomEloquentCollection->mergeRecursive([1 => new User()]));
assertType('Illuminate\Support\Collection<string, int>', $items->mergeRecursive(['foo' => 2]));
assertType('Illuminate\Database\Eloquent\Collection<(int|string), int>', $collection->combine([1]));
assertType('App\TransactionCollection<(int|string), int>', $customEloquentCollection->combine([1]));
assertType('App\UserCollection', $secondCustomEloquentCollection->combine([1]));
assertType('Illuminate\Support\Collection<(int|string), string>', $items->combine(['foo']));
assertType('App\User|null', $collection->pop(1));
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->pop(2));
assertType('App\UserCollection', $secondCustomEloquentCollection->pop(2));
assertType('Illuminate\Support\Collection<int, int>', $items->pop(3));
assertType('App\Role', User::firstOrFail(1)->roles->random());
assertType('App\RoleCollection<int, App\Role>', User::firstOrFail(1)->roles->random(1));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->random(1));
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->random(2));
assertType('App\UserCollection', $secondCustomEloquentCollection->random(2));
assertType('Illuminate\Support\Collection<int, int>', $items->random(3));
assertType('App\User|null', $collection->shift(1));
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->shift(2));
assertType('App\UserCollection', $secondCustomEloquentCollection->shift(2));
assertType('Illuminate\Support\Collection<int, int>', $items->shift(3));
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $collection->sliding(1));
assertType('App\TransactionCollection<int, App\TransactionCollection<int, App\Transaction>>', $customEloquentCollection->sliding(2));
assertType('App\UserCollection', $secondCustomEloquentCollection->sliding(2));
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<string, int>>', $items->sliding(3));
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $collection->split(1));
assertType('App\TransactionCollection<int, App\TransactionCollection<int, App\Transaction>>', $customEloquentCollection->split(2));
assertType('App\UserCollection', $secondCustomEloquentCollection->split(2));
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<string, int>>', $items->split(3));
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $collection->splitIn(1));
assertType('App\TransactionCollection<int, App\TransactionCollection<int, App\Transaction>>', $customEloquentCollection->splitIn(2));
assertType('App\UserCollection', $secondCustomEloquentCollection->splitIn(2));
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<string, int>>', $items->splitIn(3));
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $collection->chunk(1));
assertType('App\TransactionCollection<int, App\TransactionCollection<int, App\Transaction>>', $customEloquentCollection->chunk(2));
assertType('App\UserCollection', $secondCustomEloquentCollection->chunk(2));
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<string, int>>', $items->chunk(3));
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $collection->chunkWhile(fn (User $u) => $u->id > 5));
assertType('App\TransactionCollection<int, App\TransactionCollection<int, App\Transaction>>', $customEloquentCollection->chunkWhile(fn (Transaction $t) => $t->id > 5));
assertType('App\UserCollection', $secondCustomEloquentCollection->chunkWhile(fn (User $t) => $t->id > 5));
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<string, int>>', $items->chunkWhile(fn ($v) => $v > 5));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->values());
assertType('App\TransactionCollection<int, App\Transaction>', $customEloquentCollection->values());
assertType('App\UserCollection', $secondCustomEloquentCollection->values());
assertType('Illuminate\Support\Collection<int, int>', $items->values());
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<int, App\User|int>>', $collection->zip([1]));
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<int, App\Transaction|string>>', $customEloquentCollection->zip(['foo']));
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<int, App\User|string>>', $secondCustomEloquentCollection->zip(['foo']));
assertType('Illuminate\Support\Collection<int, Illuminate\Support\Collection<int, int|string>>', $items->zip(['foo', 'bar']));
assertType('Illuminate\Support\Collection<int<0, 1>, Illuminate\Support\Collection<string, int>>', $items->partition('foo'));
assertType('Illuminate\Support\Collection<int, App\User|int>', $collection->pad(10, 10));
assertType('Illuminate\Support\Collection<int, App\Transaction|string>', $customEloquentCollection->pad(10, 'foo'));
assertType('Illuminate\Support\Collection<int, App\User|string>', $secondCustomEloquentCollection->pad(10, 'foo'));
assertType('Illuminate\Support\Collection<int, int|string>', $items->pad(1, 'bar'));
assertType('Illuminate\Support\Collection<(int|string), int>', $collection->countBy('email'));
assertType('Illuminate\Support\Collection<(int|string), int>', $customEloquentCollection->countBy('foo'));
assertType('Illuminate\Support\Collection<(int|string), int>', $secondCustomEloquentCollection->countBy('foo'));
assertType('Illuminate\Support\Collection<(int|string), int>', $items->countBy('bar'));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->concat([new User()]));
assertType('App\TransactionCollection<int, App\Transaction|App\User>', $customEloquentCollection->concat([new User()]));
assertType('App\UserCollection', $secondCustomEloquentCollection->concat([new User()]));
assertType('Illuminate\Support\Collection<string, App\User|int>', $items->concat([new User()]));
////////////////////////////
// EnumeratesValues Trait //
////////////////////////////
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', EloquentCollection::make([new User()]));
assertType('App\TransactionCollection<int, App\Transaction>', TransactionCollection::make([new Transaction()]));
assertType('Illuminate\Support\Collection<int, int>', SupportCollection::make([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<(int|string), App\User>', EloquentCollection::wrap([new User()]));
assertType('App\TransactionCollection<(int|string), App\Transaction>', TransactionCollection::wrap([new Transaction()]));
assertType('Illuminate\Support\Collection<(int|string), int>', SupportCollection::wrap([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', EloquentCollection::times(10, fn ($int) => new User));
assertType('App\TransactionCollection<int, App\Transaction>', TransactionCollection::times(10, fn ($int) => new Transaction));
assertType('Illuminate\Support\Collection<int, int>', SupportCollection::times(10, fn ($int) => 5));
assertType('Illuminate\Support\LazyCollection<int, int>', LazyCollection::times(10, fn ($int) => 5));
// In runtime it returns `Illuminate\Support\Collection<string, Illuminate\Database\Eloquent\Collection<int, int>>`
// Might be fixed in Laravel or needs a separate extension
assertType(
'Illuminate\Database\Eloquent\Collection<string, Illuminate\Database\Eloquent\Collection<int, int>>',
$collection->mapToGroups(fn (User $user, int $key): array => ['foo' => $user->id])
);
assertType(
'Illuminate\Database\Eloquent\Collection<int, int>',
$collection->flatMap(function (User $user, int $id) {
return [$user->id];
})
);
assertType(
'Illuminate\Support\Collection<int, int>',
$items->flatMap(function (int $int) {
return [$int * 2];
})
);
assertType(
'Illuminate\Support\LazyCollection<int, int>',
$lazyCollection->flatMap(function (User $user, int $id) {
return [$user->id];
})
);
assertType(
'Illuminate\Support\LazyCollection<int, int>',
LazyCollection::times(10, fn ($int) => 5)->flatMap(fn (int $i) => [$i * 2]),
);
assertType('Illuminate\Support\Collection<(int|string), Illuminate\Support\Collection<int, array{id: int, type: string}>>', collect([
[
'id' => 1,
'type' => 'A',
],
[
'id' => 1,
'type' => 'B',
],
])->groupBy('type'));
assertType('int|false', $enumerableIntUsers->search(fn(User $user) => $user->id === 1));
assertType('string|false', $enumerableStringUsers->search(fn(User $user) => $user->id === 1));
} | @param EloquentCollection<int, User> $collection
@param SupportCollection<string, int> $items
@param TransactionCollection<int, Transaction> $customEloquentCollection
@param UserCollection $secondCustomEloquentCollection
@param LazyCollection<int, User> $lazyCollection
@param User $user
@param Enumerable<int, User> $enumerableIntUsers
@param Enumerable<string, User> $enumerableStringUsers | test | php | larastan/larastan | tests/Type/data/collection-generic-static-methods.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/collection-generic-static-methods.php | MIT |
function test(
EloquentCollection $ints,
EloquentCollection $users,
Traversable $traversable
): void {
assertType('Illuminate\Support\Collection<(int|string), mixed>', collect());
assertType('Illuminate\Support\Collection<0, 1>', collect(1));
assertType('Illuminate\Support\Collection<0, \'foo\'>', collect('foo'));
assertType('Illuminate\Support\Collection<0, 3.14>', collect(3.14));
assertType('Illuminate\Support\Collection<0, true>', collect(true));
assertType('Illuminate\Support\Collection<(int|string), mixed>', collect([]));
assertType('Illuminate\Support\Collection<int, int>', collect([1, 2, 3]));
assertType('Illuminate\Support\Collection<int, string>', collect(['foo', 'bar', 'baz']));
assertType('Illuminate\Support\Collection<int, float>', collect([1.0, 2.0, 3.0]));
assertType('Illuminate\Support\Collection<int, float|int|string>', collect([1, 'foo', 1.0]));
assertType("Illuminate\Support\Collection<int, array{string, string, string}>", collect([['a', 'b', 'c']]));
assertType("Illuminate\Support\Collection<int, array{string, string, string}>", collect([['a', 'b', 'c']])->push(array_fill(0, 3, 'x')));
assertType("Illuminate\Support\Collection<int, App\User>", collect([new User, new User]));
assertType("Illuminate\Support\Collection<int, array{App\User, App\User, App\User}>", collect([[new User, new User, new User]]));
assertType('Illuminate\Support\Collection<int, int>', collect($ints));
assertType('Illuminate\Support\Collection<int, App\User>', collect($users));
assertType('Illuminate\Support\Collection<int, int>', collect($traversable));
} | @param EloquentCollection<int, int> $ints
@param EloquentCollection<int, User> $users
@param Traversable<int, int> $traversable | test | php | larastan/larastan | tests/Type/data/collection-helper.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/collection-helper.php | MIT |
function test(EloquentCollection $users, Traversable $traversable): void
{
// assertType('Illuminate\Support\Collection<int|string, mixed>', SupportCollection::make([]));
assertType('Illuminate\Support\Collection<int, int>', SupportCollection::make([1, 2, 3]));
assertType('Illuminate\Support\Collection<int, string>', SupportCollection::make(['foo', 'bar', 'baz']));
assertType('Illuminate\Support\Collection<int, float>', SupportCollection::make([1.0, 2.0, 3.0]));
assertType('Illuminate\Support\Collection<int, float|int|string>', SupportCollection::make([1, 'foo', 1.0]));
assertType('Illuminate\Support\Collection<int, App\User>', SupportCollection::make($users));
/** @var EloquentCollection<int, User> $users */
assertType('Illuminate\Support\Collection<int, App\User>', SupportCollection::make($users));
assertType('Illuminate\Support\Collection<int, int>', SupportCollection::make($traversable));
} | @param EloquentCollection<int, \App\User> $users
@param Traversable<int, int> $traversable | test | php | larastan/larastan | tests/Type/data/collection-make-static.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/collection-make-static.php | MIT |
function test(
EloquentCollection $collection,
SupportCollection $items,
SupportCollection $collectionOfUsers,
User $user,
): void {
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::all()->each(function (User $user, int $key): void {
}));
assertType('Illuminate\Support\Collection<string, int>', $items->each(function (): bool {
return false;
}));
assertType('Illuminate\Support\Collection<string, lowercase-string&numeric-string&uppercase-string>', $items->map(function (int $item): string {
return (string) $item;
}));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->find($items));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->find([1]));
assertType('App\User|null', $collection->find($user));
assertType('App\User|null', $collection->find(1));
assertType('App\User|false', $collection->find(1, false));
assertType('Illuminate\Support\Collection<(int|string), mixed>', $collection->pluck('id'));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::all()->mapInto(User::class));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->flatMap(function (User $user, int $id): array {
return [$user];
}));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->tap(function ($collection): void {
}));
$foo = collect([
[
'id' => 1,
'type' => 'A',
],
[
'id' => 1,
'type' => 'B',
],
]);
$foo
->groupBy('type')
->map(function ($grouped, $groupKey): array {
assertType('(int|string)', $groupKey);
});
assertType('App\User|null', $collection->first());
assertType('App\User|false', $collection->first(null, false));
assertType('App\User|null', $collection->first(function ($user) {
assertType('App\User', $user);
return $user->id > 1;
}));
assertType('App\User|false', $collection->first(function (User $user) {
assertType('App\User', $user);
return $user->id > 1;
}, function () {
return false;
}));
assertType('App\User|null', $collection->firstWhere('blocked'));
assertType('App\User|null', $collection->firstWhere('blocked', true));
assertType('App\User|null', $collection->firstWhere('blocked', '=', true));
assertType('App\User|null', $collection->last());
assertType('App\User|false', $collection->last(null, false));
assertType('App\User|null', $collection->last(function (User $user) {
return $user->id > 1;
}));
assertType('App\User|false', $collection->last(function (User $user) {
return $user->id > 1;
}, function () {
return false;
}));
assertType('App\User|null', $collection->get(1));
assertType('App\User', $collection->get(1, new User()));
assertType('App\User|null', $collection->pull(1));
assertType('App\User', $collection->pull(1, new User()));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::all()->filter());
assertType('App\User', $collection->random());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->random(5));
assertType('App\User', $collectionOfUsers->random());
assertType('Illuminate\Support\Collection<int, App\User>', $collectionOfUsers->random(5));
assertType('App\User|null', $collection->pop());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->pop(5));
assertType('App\User|null', $collectionOfUsers->pop());
assertType('Illuminate\Support\Collection<int, App\User>', $collectionOfUsers->pop(5));
assertType('App\User|null', $collection->shift());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection->shift(5));
assertType('App\User|null', $collectionOfUsers->shift());
assertType('Illuminate\Support\Collection<int, App\User>', $collectionOfUsers->shift(5));
} | @param EloquentCollection<int, User> $collection
@param SupportCollection<string, int> $items
@param SupportCollection<int, User> $collectionOfUsers | test | php | larastan/larastan | tests/Type/data/collection-stubs.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/collection-stubs.php | MIT |
function test(EloquentCollection $foo): void
{
assertType('Illuminate\Support\Collection<int, int|string>', collect([1, 2, null, '', 'hello'])->whereNotNull());
assertType('Illuminate\Support\Collection<int, int|string>', collect([1, 2, null, '', 'hello'])->whereNotNull());
assertType('Illuminate\Support\Collection<int, int|string>', collect([1, 2, null, '', 'hello'])->whereNotNull(null));
assertType(
'Illuminate\Support\Collection<int, App\User|array{id: \'foo\'}|stdClass>',
collect([new \App\User, new \stdClass, ['id' => 'foo'], 'foo', true, 22])->whereNotNull('id')
);
assertType("Illuminate\Database\Eloquent\Collection<int, App\User>", $foo->whereNotNull('blocked'));
assertType("Illuminate\Database\Eloquent\Collection<int, App\User>", $foo->whereNotNull('blocked'));
assertType("Illuminate\Database\Eloquent\Collection<int, App\User>", $foo->whereNotNull());
} | @param EloquentCollection<int, ?\App\User> $foo | test | php | larastan/larastan | tests/Type/data/collection-where-not-null.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/collection-where-not-null.php | MIT |
public function scopeFoo(CustomEloquentBuilder $query, string $foo): CustomEloquentBuilder
{
return $query->where(['email' => $foo]);
} | @param CustomEloquentBuilder<ModelWithCustomBuilder> $query
@phpstan-return CustomEloquentBuilder<ModelWithCustomBuilder> | scopeFoo | php | larastan/larastan | tests/Type/data/custom-eloquent-builder.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/custom-eloquent-builder.php | MIT |
public function newEloquentBuilder($query): CustomEloquentBuilder
{
return new CustomEloquentBuilder($query);
} | @param \Illuminate\Database\Query\Builder $query
@return CustomEloquentBuilder<ModelWithCustomBuilder> | newEloquentBuilder | php | larastan/larastan | tests/Type/data/custom-eloquent-builder.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/custom-eloquent-builder.php | MIT |
public function categories(array $categories): CustomEloquentBuilder
{
assertType('CustomEloquentBuilder\CustomEloquentBuilder<TModel of CustomEloquentBuilder\ModelWithCustomBuilder (class CustomEloquentBuilder\CustomEloquentBuilder, argument)>', $this->whereIn('category', $categories));
return $this->whereIn('category', $categories);
} | @param string[] $categories
@phpstan-return CustomEloquentBuilder<ModelWithCustomBuilder> | categories | php | larastan/larastan | tests/Type/data/custom-eloquent-builder.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/custom-eloquent-builder.php | MIT |
public function newEloquentBuilder($query): CustomBuilder2
{
return new CustomBuilder2($query);
} | @param \Illuminate\Database\Query\Builder $query
@return CustomBuilder2<ModelWithCustomBuilderAndDocBlocks> | newEloquentBuilder | php | larastan/larastan | tests/Type/data/custom-eloquent-builder.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/custom-eloquent-builder.php | MIT |
public function newEloquentBuilder($query): ChildNonGenericBuilder
{
return new ChildNonGenericBuilder($query);
} | @param \Illuminate\Database\Query\Builder $query
@return ChildNonGenericBuilder | newEloquentBuilder | php | larastan/larastan | tests/Type/data/custom-eloquent-builder.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/custom-eloquent-builder.php | MIT |
function test(
User $user,
Post $post,
Builder $userBuilder,
OnlyUsers&User $userAndAuth,
Builder $userOrTeamBuilder,
Builder $templateBuilder,
): void {
User::query()->has('accounts', '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->has('users', '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->doesntHave('accounts', 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->doesntHave('users', 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->whereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->whereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->orWhereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->orWhereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->hasMorph('accounts', [], '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->hasMorph('users', [], '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->doesntHaveMorph('accounts', [], 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->doesntHaveMorph('users', [], 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->whereHasMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->whereHasMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->orWhereHasMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->orWhereHasMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->whereDoesntHaveMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->whereDoesntHaveMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->orWhereDoesntHaveMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->orWhereDoesntHaveMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->whereDoesntHave('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->whereDoesntHave('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->orWhereDoesntHave('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->orWhereDoesntHave('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->firstWhere(function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
Post::query()->firstWhere(function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query);
});
Post::query()->where(static function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query
->orWhere('bar', 'LIKE', '%foo%')
->orWhereRelation('users', 'name', 'LIKE', '%foo%'));
});
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::where([
['active', true],
['id', '>=', 5],
['id', '<=', 10],
])->get());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::where('id', 1)->get());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', (new User)->where('id', 1)->get());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::where('id', 1)
->whereNotNull('name')
->where('email', 'bar')
->whereFoo(['bar'])
->get());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', (new User)->whereNotNull('name')
->where('email', 'bar')
->whereFoo(['bar'])
->get());
assertType('Illuminate\Support\Collection<string, string>', User::whereIn('id', [1, 2, 3])->get()->mapWithKeys(function (User $user): array {
return [$user->name => $user->email];
}));
assertType('mixed', (new User)->where('email', 1)->max('email'));
assertType('bool', (new User)->where('email', 1)->exists());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::with('accounts')->whereNull('name'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::with('accounts')
->where('email', 'bar')
->orWhere('name', 'baz'));
assertType('App\User|null', User::with(['accounts'])->find(1));
assertType('App\User', User::with(['accounts'])->findOrFail(1));
assertType('App\User', User::with(['accounts'])->findOrNew(1));
assertType('Illuminate\Database\Eloquent\Model|null', (new CustomBuilder(User::query()->getQuery()))->with('email')->find(1));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::with(['accounts'])->find([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::with(['accounts'])->findOrNew([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::hydrate([]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::fromQuery('SELECT * FROM users'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userBuilder->whereNotNull('test'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newModelQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQueryWithoutRelationships());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQueryWithoutScopes());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQueryWithoutScope('foo'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQueryForRestoration([1]));
assertType('App\PostBuilder<App\Post>', $post->newQuery());
assertType('App\PostBuilder<App\Post>', $post->newModelQuery());
assertType('App\PostBuilder<App\Post>', $post->newQueryWithoutRelationships());
assertType('App\PostBuilder<App\Post>', $post->newQueryWithoutScopes());
assertType('App\PostBuilder<App\Post>', $post->newQueryWithoutScope('foo'));
assertType('App\PostBuilder<App\Post>', $post->newQueryForRestoration([1]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newModelQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQueryWithoutRelationships());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQueryWithoutScopes());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQueryWithoutScope('foo'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQueryForRestoration([1]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth::query());
assertType('Illuminate\Support\LazyCollection<int, App\User>', User::query()->lazy());
assertType('Illuminate\Support\LazyCollection<int, App\User>', User::query()->lazyById());
assertType('Illuminate\Support\LazyCollection<int, App\User>', User::query()->lazyByIdDesc());
assertType('Illuminate\Support\LazyCollection<int, App\User>', User::query()->cursor());
assertType('Illuminate\Support\LazyCollection<int, App\Post>', $post->newQuery()->lazy());
assertType('Illuminate\Support\LazyCollection<int, App\Post>', $post->newQuery()->lazyById());
assertType('Illuminate\Support\LazyCollection<int, App\Post>', $post->newQuery()->lazyByIdDesc());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->groupBy('foo', 'bar'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->whereEmail('bar'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->whereIdAndEmail(1, '[email protected]'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->whereEmail(1));
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->orderBy('email')
->toBase()
);
assertType('object|null', User::getQuery()
->select('some_model.created')
->where('some_model.some_column', '=', true)
->orderBy('some_model.created', 'desc')
->first()
);
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNotBetween('a', [1, 5])
->orWhereNotBetween('a', [1, 5])
->toBase()
);
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->withTrashed());
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->orderBy(\Illuminate\Support\Facades\DB::raw('name'))
->toBase()
);
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->orderBy(User::whereNotNull('name'))
->toBase()
);
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->latest(\Illuminate\Support\Facades\DB::raw('created_at'))
->toBase()
);
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->oldest(\Illuminate\Support\Facades\DB::raw('created_at'))
->toBase()
);
assertType('Illuminate\Support\Collection<(int|string), mixed>', User::query()
->whereNull('name')
->pluck(\Illuminate\Support\Facades\DB::raw('created_at'))
->toBase()
);
assertType('int', User::query()->increment(\Illuminate\Support\Facades\DB::raw('counter')));
assertType('int', User::query()->decrement(\Illuminate\Support\Facades\DB::raw('counter')));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userBuilder->macro('customMacro', function () {
}));
assertType('string', $userBuilder->globalCustomMacro('foo'));
assertType('App\User', User::with('accounts')
->where('email', 'bar')
->orWhere('name', 'baz')
->firstOrFail()
);
assertType('App\User|null', User::with('accounts')
->where('email', 'bar')
->orWhere('name', 'baz')
->first()
);
assertType('App\User|null', User::query()->firstWhere(['email' => '[email protected]']));
assertType('App\User|null', User::with('accounts')
->orWhere(\Illuminate\Support\Facades\DB::raw('name'), 'like', '%john%')
->first()
);
assertType('App\User|null', User::with('accounts')
->where(\Illuminate\Support\Facades\DB::raw('name'), 'like', '%john%')
->first()
);
assertType('App\User|null', User::with('accounts')
->firstWhere(\Illuminate\Support\Facades\DB::raw('name'), 'like', '%john%')
);
assertType('mixed', User::with('accounts')
->value(\Illuminate\Support\Facades\DB::raw('name'))
);
assertType('int', User::query()->restore());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->joinSub(
Post::query()->whereIn('id', [1, 2, 3]),
'users',
'users.id',
'posts.id'
));
assertType('Illuminate\Pagination\LengthAwarePaginator<int, App\User>', User::query()->paginate());
assertType('array<int, App\User>', User::query()->paginate()->items());
User::chunk(1000, fn ($collection) => assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection));
User::chunkById(1000, fn ($collection) => assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection));
assertType('Illuminate\Support\Collection<int, string>', User::chunkMap(function ($model) {
assertType('App\User', $model);
return $model->name;
}, 1000));
$userBuilder->chunk(1000, fn ($collection) => assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection));
$userBuilder->chunkById(1000, fn ($collection) => assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection));
assertType('Illuminate\Support\Collection<int, string>', $userBuilder->chunkMap(function ($model) {
assertType('App\User', $model);
return $model->name;
}, 1000));
assertType('App\Team|App\User', $userOrTeamBuilder->findOrFail(4));
assertType('Illuminate\Database\Eloquent\Builder<App\Team|App\User>', $userOrTeamBuilder->where('id', 5));
assertType('Illuminate\Database\Eloquent\Builder<TModel of Illuminate\Database\Eloquent\Model (function EloquentBuilder\test(), argument)>', $templateBuilder->select());
} | @template TModel of \Illuminate\Database\Eloquent\Model
@param Builder<User> $userBuilder
@param Builder<User|Team> $userOrTeamBuilder
@param Builder<TModel> $templateBuilder | test | php | larastan/larastan | tests/Type/data/eloquent-builder-l11-42.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/eloquent-builder-l11-42.php | MIT |
function test(
User $user,
Post $post,
Builder $userBuilder,
OnlyUsers&User $userAndAuth,
Builder $userOrTeamBuilder,
Builder $templateBuilder,
): void {
User::query()->has('accounts', '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->has('users', '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->doesntHave('accounts', 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->doesntHave('users', 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->whereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->whereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->orWhereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->orWhereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->hasMorph('accounts', [], '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->hasMorph('users', [], '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->doesntHaveMorph('accounts', [], 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->doesntHaveMorph('users', [], 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->whereHasMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->whereHasMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->orWhereHasMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->orWhereHasMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->whereDoesntHaveMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->whereDoesntHaveMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->orWhereDoesntHaveMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->orWhereDoesntHaveMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->whereDoesntHave('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->whereDoesntHave('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->orWhereDoesntHave('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::query()->orWhereDoesntHave('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::query()->firstWhere(function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
Post::query()->firstWhere(function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query);
});
Post::query()->where(static function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query
->orWhere('bar', 'LIKE', '%foo%')
->orWhereRelation('users', 'name', 'LIKE', '%foo%'));
});
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::where([
['active', true],
['id', '>=', 5],
['id', '<=', 10],
])->get());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::where('id', 1)->get());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', (new User)->where('id', 1)->get());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::where('id', 1)
->whereNotNull('name')
->where('email', 'bar')
->whereFoo(['bar'])
->get());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', (new User)->whereNotNull('name')
->where('email', 'bar')
->whereFoo(['bar'])
->get());
assertType('Illuminate\Support\Collection<string, string>', User::whereIn('id', [1, 2, 3])->get()->mapWithKeys(function (User $user): array {
return [$user->name => $user->email];
}));
assertType('mixed', (new User)->where('email', 1)->max('email'));
assertType('bool', (new User)->where('email', 1)->exists());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::with('accounts')->whereNull('name'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::with('accounts')
->where('email', 'bar')
->orWhere('name', 'baz'));
assertType('App\User|null', User::with(['accounts'])->find(1));
assertType('App\User', User::with(['accounts'])->findOrFail(1));
assertType('App\User', User::with(['accounts'])->findOrNew(1));
assertType('Illuminate\Database\Eloquent\Model|null', (new CustomBuilder(User::query()->getQuery()))->with('email')->find(1));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::with(['accounts'])->find([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::with(['accounts'])->findOrNew([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::hydrate([]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::fromQuery('SELECT * FROM users'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userBuilder->whereNotNull('test'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newModelQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQueryWithoutRelationships());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQueryWithoutScopes());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQueryWithoutScope('foo'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->newQueryForRestoration([1]));
assertType('App\PostBuilder<App\Post>', $post->newQuery());
assertType('App\PostBuilder<App\Post>', $post->newModelQuery());
assertType('App\PostBuilder<App\Post>', $post->newQueryWithoutRelationships());
assertType('App\PostBuilder<App\Post>', $post->newQueryWithoutScopes());
assertType('App\PostBuilder<App\Post>', $post->newQueryWithoutScope('foo'));
assertType('App\PostBuilder<App\Post>', $post->newQueryForRestoration([1]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newModelQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQueryWithoutRelationships());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQueryWithoutScopes());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQueryWithoutScope('foo'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth->newQueryForRestoration([1]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userAndAuth::query());
assertType('Illuminate\Support\LazyCollection<int, App\User>', User::query()->lazy());
assertType('Illuminate\Support\LazyCollection<int, App\User>', User::query()->lazyById());
assertType('Illuminate\Support\LazyCollection<int, App\User>', User::query()->lazyByIdDesc());
assertType('Illuminate\Support\LazyCollection<int, App\User>', User::query()->cursor());
assertType('Illuminate\Support\LazyCollection<int, App\Post>', $post->newQuery()->lazy());
assertType('Illuminate\Support\LazyCollection<int, App\Post>', $post->newQuery()->lazyById());
assertType('Illuminate\Support\LazyCollection<int, App\Post>', $post->newQuery()->lazyByIdDesc());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->groupBy('foo', 'bar'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->whereEmail('bar'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->whereIdAndEmail(1, '[email protected]'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->whereEmail(1));
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->orderBy('email')
->toBase()
);
assertType('object|null', User::getQuery()
->select('some_model.created')
->where('some_model.some_column', '=', true)
->orderBy('some_model.created', 'desc')
->first()
);
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNotBetween('a', [1, 5])
->orWhereNotBetween('a', [1, 5])
->toBase()
);
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->withTrashed());
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->orderBy(\Illuminate\Support\Facades\DB::raw('name'))
->toBase()
);
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->orderBy(User::whereNotNull('name'))
->toBase()
);
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->latest(\Illuminate\Support\Facades\DB::raw('created_at'))
->toBase()
);
assertType('Illuminate\Database\Query\Builder', User::query()
->whereNull('name')
->oldest(\Illuminate\Support\Facades\DB::raw('created_at'))
->toBase()
);
assertType('Illuminate\Support\Collection<(int|string), mixed>', User::query()
->whereNull('name')
->pluck(\Illuminate\Support\Facades\DB::raw('created_at'))
->toBase()
);
assertType('int', User::query()->increment(\Illuminate\Support\Facades\DB::raw('counter')));
assertType('int', User::query()->decrement(\Illuminate\Support\Facades\DB::raw('counter')));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $userBuilder->macro('customMacro', function () {
}));
assertType('string', $userBuilder->globalCustomMacro('foo'));
assertType('App\User', User::with('accounts')
->where('email', 'bar')
->orWhere('name', 'baz')
->firstOrFail()
);
assertType('App\User|null', User::with('accounts')
->where('email', 'bar')
->orWhere('name', 'baz')
->first()
);
assertType('App\User|null', User::query()->firstWhere(['email' => '[email protected]']));
assertType('App\User|null', User::with('accounts')
->orWhere(\Illuminate\Support\Facades\DB::raw('name'), 'like', '%john%')
->first()
);
assertType('App\User|null', User::with('accounts')
->where(\Illuminate\Support\Facades\DB::raw('name'), 'like', '%john%')
->first()
);
assertType('App\User|null', User::with('accounts')
->firstWhere(\Illuminate\Support\Facades\DB::raw('name'), 'like', '%john%')
);
assertType('mixed', User::with('accounts')
->value(\Illuminate\Support\Facades\DB::raw('name'))
);
assertType('int', User::query()->restore());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query()->joinSub(
Post::query()->whereIn('id', [1, 2, 3]),
'users',
'users.id',
'posts.id'
));
assertType('Illuminate\Pagination\LengthAwarePaginator<int, App\User>', User::query()->paginate());
assertType('array<int, App\User>', User::query()->paginate()->items());
User::chunk(1000, fn ($collection) => assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection));
User::chunkById(1000, fn ($collection) => assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection));
assertType('Illuminate\Support\Collection<int, string>', User::chunkMap(function ($model) {
assertType('App\User', $model);
return $model->name;
}, 1000));
$userBuilder->chunk(1000, fn ($collection) => assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection));
$userBuilder->chunkById(1000, fn ($collection) => assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $collection));
assertType('Illuminate\Support\Collection<int, string>', $userBuilder->chunkMap(function ($model) {
assertType('App\User', $model);
return $model->name;
}, 1000));
assertType('App\Team|App\User', $userOrTeamBuilder->findOrFail(4));
assertType('Illuminate\Database\Eloquent\Builder<App\Team|App\User>', $userOrTeamBuilder->where('id', 5));
assertType('Illuminate\Database\Eloquent\Builder<TModel of Illuminate\Database\Eloquent\Model (function EloquentBuilder\test(), argument)>', $templateBuilder->select());
} | @template TModel of \Illuminate\Database\Eloquent\Model
@param Builder<User> $userBuilder
@param Builder<User|Team> $userOrTeamBuilder
@param Builder<TModel> $templateBuilder | test | php | larastan/larastan | tests/Type/data/eloquent-builder.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/eloquent-builder.php | MIT |
function test(?int $value = 0, int|\Closure $intOrClosure = 0, int|\Closure $intOrClosureWithNoDocBlock = 0): void
{
assertType('Illuminate\Foundation\Application', app());
assertType('Larastan\Larastan\ApplicationResolver', app(ApplicationResolver::class));
assertType('Illuminate\Auth\AuthManager', app('auth'));
assertType('Larastan\Larastan\ApplicationResolver', resolve(ApplicationResolver::class));
assertType('Illuminate\Auth\AuthManager', resolve('auth'));
assertType('Illuminate\Auth\AuthManager', auth());
assertType('Illuminate\Contracts\Auth\Guard', auth()->guard('web'));
assertType('Illuminate\Contracts\Auth\StatefulGuard', auth('web'));
assertType('App\Admin|App\User|null', auth()->user());
assertType('bool', auth()->check());
assertType('App\User|null', auth()->guard('web')->user());
assertType('App\User|null', auth('web')->user());
assertType('App\Admin|null', auth()->guard('admin')->user());
assertType('App\Admin|null', auth('admin')->user());
assertType('int|string|null', auth()->id());
assertType('int|string|null', auth('web')->id());
assertType('int|string|null', auth('admin')->id());
assertType('Illuminate\Contracts\Auth\Authenticatable|false', auth()->loginUsingId(1));
assertType('null', auth()->login(new User()));
assertType('Illuminate\Support\Carbon', now());
assertType('Illuminate\Support\Carbon', today());
assertType('Illuminate\Http\RedirectResponse', redirect('/'));
assertType('Illuminate\Routing\Redirector', redirect());
assertType('Illuminate\Http\Request', request());
assertType('mixed', request('foo'));
assertType('array<string>', request(['foo', 'bar']));
assertType('\'ok\'|null', rescue(function () {
if (mt_rand(0, 1)) {
throw new Exception();
}
return 'ok';
}));
assertType('\'failed\'|\'ok\'', rescue(function () {
if (mt_rand(0, 1)) {
throw new Exception();
}
return 'ok';
}, 'failed'));
assertType('0|\'ok\'', rescue(function () {
if (mt_rand(0, 1)) {
throw new Exception();
}
return 'ok';
}, function () {
return 0;
}));
assertType('0|\'ok\'', rescue(function () {
if (mt_rand(0, 1)) {
throw new Exception();
}
return 'ok';
}, function (Throwable $e) {
return 0;
}));
assertType('\'failed\'|\'ok\'', rescue(function () {
if (mt_rand(0, 1)) {
throw new Exception();
}
return 'ok';
}, 'failed', false));
assertType('Illuminate\Http\Response', response('foo'));
assertType('Illuminate\Contracts\Routing\ResponseFactory', response());
assertType('null', retry(3, function () {
}));
assertType('5', retry(3, function (): int {
return 5;
}));
assertType('App\User|null', retry(5, function (): ?User {
return User::first();
}, 0, function (): bool {
return true;
}));
assertType('false', retry(5, function (int $attempt): bool {
return false;
}, 0, function (Exception $e): bool {
return true;
}));
assertType('Illuminate\Support\Stringable', str('foo'));
assertType('mixed', str());
assertType("'Laravel'", Str::replace('foo', 'bar', 'Laravel'));
assertType("array{'Laravel', 'Framework'}", Str::replace('foo', 'bar', ['Laravel', 'Framework']));
assertType('array<int|string, string>', Str::replace('foo', 'bar', collect(['Laravel', 'Framework'])));
assertType('App\User', tap(new User(), function (User $user): void {
$user->name = 'Can Vural';
$user->save();
}));
assertType('Illuminate\Support\HigherOrderTapProxy<App\User>', tap(new User()));
assertType('App\User', tap(new User())->update(['name' => 'Taylor Otwell']));
assertType('Illuminate\Contracts\Validation\Validator&Illuminate\Validation\Validator', tap(validator([], []))->addReplacers());
assertType('string', url('/path'));
assertType('Illuminate\Contracts\Routing\UrlGenerator', url());
assertType('Illuminate\Contracts\Validation\Factory', validator());
assertType('Illuminate\Contracts\Validation\Validator&Illuminate\Validation\Validator', validator(['foo' => 'bar'], ['foo' => 'required']));
assertType('array', validator(['foo' => 'bar'], ['foo' => 'required'])->valid());
assertType('App\User|null', value(function (): ?User {
return User::first();
}));
assertType('5', value(5));
assertType('int|string', value($intOrClosure));
assertType('mixed', value($intOrClosureWithNoDocBlock));
assertType('array<mixed>|null', transform(User::first(), fn (User $user) => $user->toArray()));
assertType('array<mixed>', transform(User::sole(), fn (User $user) => $user->toArray()));
// falls back to default if provided
assertType("1|'default'", transform(optional(), fn () => 1, 'default'));
// default as callable
assertType('1|\'string\'', transform(optional(), fn () => 1, fn () => 'string'));
// non empty values
assertType('1', transform('filled', fn () => 1));
assertType('1', transform(['filled'], fn () => 1));
assertType('1', transform(new User(), fn () => 1));
// "empty" values
assertType('null', transform(null, fn () => 1));
assertType('null', transform('', fn () => 1));
assertType('null', transform([], fn () => 1));
if (filled($value)) {
assertType('int', $value);
} else {
assertType('int|null', $value);
}
if (blank($value)) {
assertType('int|null', $value);
} else {
assertType('int', $value);
}
assertType('bool|string|null', env('foo'));
assertType('bool|string|null', env('foo'));
assertType('int', env('foo', 120));
assertType('string', env('foo', ''));
assertType('int', env('foo', fn () => 120));
assertType('true', literal(true));
assertType('int<0, 10>', literal(random_int(0,10)));
assertType("object{bar: 'bar'}&stdClass", literal(bar: "bar"));
assertType("object{foo: 22, bar: 'bar'}&stdClass", literal(foo: 22, bar: "bar"));
assertType("object{foo: int<0, 5>, bar: 'bar'}&stdClass", literal(foo: random_int(0,5), bar: "bar"));
assertType("object{}&stdClass", literal(new \stdClass));
assertType("object{}&stdClass", literal());
assertType("object{0: 'bar', 1: 'foo'}&stdClass", literal('bar', 'foo'));
assertType("object{0: 4, bar: 'foo'}&stdClass", literal(4, bar:'foo'));
assertType("App\User", literal(new User()));
assertType("array{foo: 22, bar: 'bar'}", literal(['foo' => 22, 'bar' => "bar"]));
assertType("object{0: 5, 1: 7}&stdClass", literal(...[5,7]));
assertType("object{foo: 22, bar: 'bar'}&stdClass", literal(...['foo' => 22, 'bar' => "bar"]));
} | @param int|null $value
@param int|(\Closure(mixed): string) $intOrClosure
@return void
@throws Throwable | test | php | larastan/larastan | tests/Type/data/helpers.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/helpers.php | MIT |
function testUnion($parameter): int {
assertType("(object{foo: 'foo', bar: 'baa'}&stdClass)|(object{loo: 'loo'}&stdClass)", literal(...$parameter));
return 0;
} | @param array{loo:'loo'}|array{foo:'foo',bar:'baa'} $parameter | testUnion | php | larastan/larastan | tests/Type/data/helpers.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/helpers.php | MIT |
function test(
EloquentCollection $users,
User $user,
SupportCollection $collection,
SupportCollection $supportCollectionWithModels,
NonGenericCollection $nonGenericCollection,
OnlyValueGenericCollection $onlyValueGenericCollection,
TransactionCollection $transactionCollection,
): void {
assertType('float', $users->avg->id() + $users->average->id());
assertType('bool', $users->contains->isActive());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->each->delete());
assertType('bool', $users->every->isActive());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->filter->isActive());
assertType('App\User|null', $users->first->isActive());
assertType('Illuminate\Support\Collection<int, mixed>', $users->flatMap->isActive());
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $users->groupBy->isActive());
assertType('Illuminate\Database\Eloquent\Collection<(int|string), App\User>', $users->keyBy->isActive());
assertType('Illuminate\Support\Collection<(int|string), bool>', $users->map->isActive());
assertType('Illuminate\Support\Collection<(int|string), Illuminate\Database\Eloquent\Relations\HasMany<App\Account, App\User>>', $users->map->accounts());
assertType('Illuminate\Support\Collection<(int|string), int>', $users->map->id());
// assertType('array<int, array>', $user->accounts->map->getAttributes()->all());
assertType('int', $users->max->id());
assertType('int', $users->min->id());
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $users->partition->isActive());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->reject->isActive());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->skipUntil->isActive());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->skipWhile->isActive());
assertType('int', $users->sum->id());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->takeUntil->isActive());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->takeWhile->isActive());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->unique->isActive());
assertType('Illuminate\Support\Collection<(int|string), bool>', $collection->map->import());
assertType('Illuminate\Support\Collection<int, App\Importer>', $collection->each->import());
assertType('Illuminate\Support\Collection<int, App\Importer>', $collection->filter->isImported());
assertType('float', $users->avg->id + $users->average->id);
assertType('bool', $users->contains->email);
assertType('bool', $users->every->email);
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->each->email);
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->filter->email);
assertType('Illuminate\Support\Collection<int, mixed>', $users->flatMap->email);
assertType('App\User|null', $users->first->email);
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $users->groupBy->email);
assertType('Illuminate\Database\Eloquent\Collection<(int|string), App\User>', $users->keyBy->email);
assertType('Illuminate\Support\Collection<(int|string), string>', $users->map->email);
assertType('Illuminate\Support\Collection<(int|string), int>', $users->map->id);
assertType('Illuminate\Support\Collection<(int|string), int<0, max>>', $users->groupBy('status')->map->count());
assertType('Illuminate\Support\Collection<(int|string), Carbon\Carbon|null>', $users->map->created_at);
assertType('string', $users->max->email);
assertType('int', $users->max->id);
assertType('string', $users->min->email);
assertType('int', $users->min->id);
assertType('Illuminate\Database\Eloquent\Collection<int, Illuminate\Database\Eloquent\Collection<int, App\User>>', $users->partition->email);
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->reject->email);
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->skipUntil->email);
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->skipWhile->email);
assertType('int', $users->sum->id);
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->takeUntil->email);
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $users->takeWhile->email);
assertType('Illuminate\Support\Collection<int, App\User>', $supportCollectionWithModels->reject->isActive());
// Custom collections
assertType('App\NonGenericCollection', $nonGenericCollection->each->count());
assertType('App\NonGenericCollection', $nonGenericCollection->reject->id);
assertType('App\OnlyValueGenericCollection<App\ModelWithOnlyValueGenericCollection>', $onlyValueGenericCollection->each->count());
assertType('App\OnlyValueGenericCollection<App\ModelWithOnlyValueGenericCollection>', $onlyValueGenericCollection->reject->id);
assertType('App\TransactionCollection<int, App\Transaction>', $transactionCollection->each->count());
assertType('App\TransactionCollection<int, App\Transaction>', $transactionCollection->reject->id);
} | @param EloquentCollection<int, User> $users
@param SupportCollection<int, Importer> $collection
@param SupportCollection<int, User> $supportCollectionWithModels
@param OnlyValueGenericCollection<ModelWithOnlyValueGenericCollection> $onlyValueGenericCollection
@param TransactionCollection<int, Transaction> $transactionCollection | test | php | larastan/larastan | tests/Type/data/higher-order-collection-proxy-methods.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/higher-order-collection-proxy-methods.php | MIT |
function test(
Model $model,
string $modelClass,
string $userOrPostClass,
string $userOrAccountClass,
FormRequest $request,
User $user,
): void {
/** @var array<string, string> $requestData */
$requestData = $request->validated();
assertType('Model\Child', Child::new());
assertType('App\User|null', User::find(1));
assertType('Model\Bar|null', Bar::findByHashId('1'));
assertType('Illuminate\Database\Eloquent\Model|null', $model::find(1));
assertType('Illuminate\Database\Eloquent\Model|null', $modelClass::find(1));
assertType('App\Post|App\User|null', $userOrPostClass::find(1));
assertType('Illuminate\Database\Eloquent\Collection<int, App\Post>|Illuminate\Database\Eloquent\Collection<int, App\User>', $userOrPostClass::find([1, 2, 3]));
assertType('App\AccountCollection<int, App\Account>|Illuminate\Database\Eloquent\Collection<int, App\User>', $userOrAccountClass::find([1, 2, 3]));
assertType('App\AccountCollection<int, App\Account>|Illuminate\Database\Eloquent\Collection<int, App\User>', $userOrAccountClass::all());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::find([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::findMany([1, 2, 3]));
assertType('App\User', User::findOrFail(1));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::findOrFail([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::findOrFail([1, 2, 3])->makeHidden('foo'));
assertType('App\User|null', User::findOrFail([1, 2, 3])->makeHidden('foo')->first());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::find((array) $requestData['user_ids']));
assertType('App\User|null', User::find((int) '1'));
assertType('App\User', $user->make([]));
assertType('Illuminate\Database\Query\Builder', User::getQuery());
assertType('Illuminate\Database\Query\Builder', User::toBase());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::all());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::join('tickets.tickets', 'tickets.tickets.id', '=', 'tickets.sale_ticket.ticket_id'));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', (new Thread)->where(['name' => 'bar']));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::where(['name' => 'bar']));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', (new Thread)->whereName(['bar']));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::whereName(['bar']));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', (new Thread)->whereIn('id', [1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', (new User)->withWhereHas('accounts', function ($query) {
return $query->where('active', true);
}));
assertType('int', $user->increment('counter'));
assertType('int', $user->decrement('counter'));
assertType('App\User|null', User::first());
assertType('App\User', User::make([]));
assertType('App\User', User::create([]));
assertType('App\User', User::forceCreate([]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::findOrNew([]));
assertType('App\User', User::firstOrNew([]));
assertType('App\User', User::updateOrCreate([]));
assertType('App\User', User::firstOrCreate([]));
assertType('App\User', User::createOrFirst([]));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid());
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid()->orWhere->valid());
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid()->orWhereNot->valid());
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid()->whereNot->valid());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::with(['accounts' => function ($relation) {
return $relation->where('active', true);
}]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', (new User)->withGlobalScope('test', function () {
}));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', (new User)->withoutGlobalScope('test'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::onlyTrashed());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::withTrashed());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::withTrashed(false));
assertType('App\User', User::onlyTrashed()->findOrFail(5));
assertType('bool', $user->restore());
assertType('App\User', User::restoreOrCreate(['id' => 1]));
assertType('App\User|null', User::firstWhere(['email' => '[email protected]']));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->with('accounts'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->with('accounts')->with('group'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->with(['accounts' => function (Relation $relation) {
// TODO: fix this once we have closure parameter type changing extensions implemented
// assertType('Illuminate\Database\Eloquent\Relations\Relation<Illuminate\Database\Eloquent\Model>', $relation->orderBy('id'));
}]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::lockForUpdate());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::sharedLock());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', Thread::methodReturningCollectionOfAnotherModel());
assertType('App\Thread|Illuminate\Database\Eloquent\Collection<int, App\Thread>', Thread::methodReturningUnionWithCollection());
assertType('App\User|Illuminate\Database\Eloquent\Collection<int, App\User>', Thread::methodReturningUnionWithCollectionOfAnotherModel());
assertType('mixed', $user->min('id'));
assertType('App\User', User::sole());
/** @var class-string<User> $className */
$className = User::class;
assertType('App\User', new $className());
assertType('App\User', $className::create());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', (new $className())->newQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $className::query());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $className::query()->active());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $className::query()->active()->get());
assertType('string', Thread::valid()->toRawSql());
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid()->dumpRawSql());
User::has('accounts', '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::has('users', '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::doesntHave('accounts', 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::doesntHave('users', 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::where(function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
Post::where(function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query);
});
User::orWhere(function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
Post::orWhere(function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query);
});
User::whereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::whereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::withWhereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<*>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::withWhereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<*>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::orWhereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::orWhereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::hasMorph('accounts', [], '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::hasMorph('users', [], '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::doesntHaveMorph('accounts', [], 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::doesntHaveMorph('users', [], 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::whereHasMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::whereHasMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::orWhereHasMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::orWhereHasMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::whereDoesntHaveMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::whereDoesntHaveMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::orWhereDoesntHaveMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::orWhereDoesntHaveMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::whereDoesntHave('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::whereDoesntHave('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::orWhereDoesntHave('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::orWhereDoesntHave('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::firstWhere(function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
Post::firstWhere(function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query);
});
} | @param class-string<Model> $modelClass
@param class-string<User>|class-string<Post> $userOrPostClass
@param class-string<User>|class-string<Account> $userOrAccountClass | test | php | larastan/larastan | tests/Type/data/model-l11-42.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/model-l11-42.php | MIT |
public function relationReturningUnion(): HasMany|BelongsTo
{
return $this->name === 'foo' ? $this->hasMany(Bar::class) : $this->belongsTo(Baz::class);
} | @return HasMany<Bar, $this>|BelongsTo<Baz, $this> | relationReturningUnion | php | larastan/larastan | tests/Type/data/model-properties-relations.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/model-properties-relations.php | MIT |
public function relationReturningUnion2(): HasMany|BelongsTo
{
return $this->name === 'foo' ? $this->hasMany(Bar::class) : $this->belongsTo(Baz::class);
} | @return HasMany<Bar, $this>|BelongsTo<Baz, $this> | relationReturningUnion2 | php | larastan/larastan | tests/Type/data/model-properties-relations.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/model-properties-relations.php | MIT |
public function casts(): array
{
$argument = 'argument';
return [
'integer' => 'bool', // overrides the cast from the property
'string' => AsStringable::class.':'.$argument,
];
} | @return array{integer: 'bool', string: 'Illuminate\\Database\\Eloquent\\Casts\\AsStringable:argument'} | casts | php | larastan/larastan | tests/Type/data/model-properties.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/model-properties.php | MIT |
#[Scope]
protected function completed(Builder $query, bool $completed = true): Builder
{
return $query->where('completed', $completed);
} | @param Builder<static> $query
@return Builder<static> | completed | php | larastan/larastan | tests/Type/data/model-scope-attribute-l12.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/model-scope-attribute-l12.php | MIT |
function test(
Model $model,
string $modelClass,
string $userOrPostClass,
string $userOrAccountClass,
FormRequest $request,
User $user,
): void {
/** @var array<string, string> $requestData */
$requestData = $request->validated();
assertType('Model\Child', Child::new());
assertType('App\User|null', User::find(1));
assertType('Model\Bar|null', Bar::findByHashId('1'));
assertType('Illuminate\Database\Eloquent\Model|null', $model::find(1));
assertType('Illuminate\Database\Eloquent\Model|null', $modelClass::find(1));
assertType('App\Post|App\User|null', $userOrPostClass::find(1));
assertType('Illuminate\Database\Eloquent\Collection<int, App\Post>|Illuminate\Database\Eloquent\Collection<int, App\User>', $userOrPostClass::find([1, 2, 3]));
assertType('App\AccountCollection<int, App\Account>|Illuminate\Database\Eloquent\Collection<int, App\User>', $userOrAccountClass::find([1, 2, 3]));
assertType('App\AccountCollection<int, App\Account>|Illuminate\Database\Eloquent\Collection<int, App\User>', $userOrAccountClass::all());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::find([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::findMany([1, 2, 3]));
assertType('App\User', User::findOrFail(1));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::findOrFail([1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::findOrFail([1, 2, 3])->makeHidden('foo'));
assertType('App\User|null', User::findOrFail([1, 2, 3])->makeHidden('foo')->first());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::find((array) $requestData['user_ids']));
assertType('App\User|null', User::find((int) '1'));
assertType('App\User', $user->make([]));
assertType('Illuminate\Database\Query\Builder', User::getQuery());
assertType('Illuminate\Database\Query\Builder', User::toBase());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::all());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::join('tickets.tickets', 'tickets.tickets.id', '=', 'tickets.sale_ticket.ticket_id'));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', (new Thread)->where(['name' => 'bar']));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::where(['name' => 'bar']));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', (new Thread)->whereName(['bar']));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::whereName(['bar']));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', (new Thread)->whereIn('id', [1, 2, 3]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', (new User)->withWhereHas('accounts', function ($query) {
return $query->where('active', true);
}));
assertType('int', $user->increment('counter'));
assertType('int', $user->decrement('counter'));
assertType('App\User|null', User::first());
assertType('App\User', User::make([]));
assertType('App\User', User::create([]));
assertType('App\User', User::forceCreate([]));
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', User::findOrNew([]));
assertType('App\User', User::firstOrNew([]));
assertType('App\User', User::updateOrCreate([]));
assertType('App\User', User::firstOrCreate([]));
assertType('App\User', User::createOrFirst([]));
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid());
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid()->orWhere->valid());
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid()->orWhereNot->valid());
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid()->whereNot->valid());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::with(['accounts' => function ($relation) {
return $relation->where('active', true);
}]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', (new User)->withGlobalScope('test', function () {
}));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', (new User)->withoutGlobalScope('test'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::onlyTrashed());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::withTrashed());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::withTrashed(false));
assertType('App\User', User::onlyTrashed()->findOrFail(5));
assertType('bool', $user->restore());
assertType('App\User', User::restoreOrCreate(['id' => 1]));
assertType('App\User|null', User::firstWhere(['email' => '[email protected]']));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->with('accounts'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->with('accounts')->with('group'));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $user->with(['accounts' => function (Relation $relation) {
// TODO: fix this once we have closure parameter type changing extensions implemented
// assertType('Illuminate\Database\Eloquent\Relations\Relation<Illuminate\Database\Eloquent\Model>', $relation->orderBy('id'));
}]));
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::lockForUpdate());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::sharedLock());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', User::query());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', Thread::methodReturningCollectionOfAnotherModel());
assertType('App\Thread|Illuminate\Database\Eloquent\Collection<int, App\Thread>', Thread::methodReturningUnionWithCollection());
assertType('App\User|Illuminate\Database\Eloquent\Collection<int, App\User>', Thread::methodReturningUnionWithCollectionOfAnotherModel());
assertType('mixed', $user->min('id'));
assertType('App\User', User::sole());
/** @var class-string<User> $className */
$className = User::class;
assertType('App\User', new $className());
assertType('App\User', $className::create());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', (new $className())->newQuery());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $className::query());
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $className::query()->active());
assertType('Illuminate\Database\Eloquent\Collection<int, App\User>', $className::query()->active()->get());
assertType('string', Thread::valid()->toRawSql());
assertType('Illuminate\Database\Eloquent\Builder<App\Thread>', Thread::valid()->dumpRawSql());
User::has('accounts', '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::has('users', '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::doesntHave('accounts', 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::doesntHave('users', 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::where(function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
Post::where(function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query);
});
User::orWhere(function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
Post::orWhere(function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query);
});
User::whereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::whereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::withWhereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::withWhereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::orWhereHas('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::orWhereHas('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::hasMorph('accounts', [], '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::hasMorph('users', [], '=', 1, 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::doesntHaveMorph('accounts', [], 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::doesntHaveMorph('users', [], 'and', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::whereHasMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::whereHasMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::orWhereHasMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::orWhereHasMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::whereDoesntHaveMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::whereDoesntHaveMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::orWhereDoesntHaveMorph('accounts', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::orWhereDoesntHaveMorph('users', [], function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::whereDoesntHave('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::whereDoesntHave('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::orWhereDoesntHave('accounts', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\Account>', $query);
});
Post::orWhereDoesntHave('users', function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder', $query);
//assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
User::firstWhere(function (Builder $query) {
assertType('Illuminate\Database\Eloquent\Builder<App\User>', $query);
});
Post::firstWhere(function (PostBuilder $query) {
assertType('App\PostBuilder<App\Post>', $query);
});
} | @param class-string<Model> $modelClass
@param class-string<User>|class-string<Post> $userOrPostClass
@param class-string<User>|class-string<Account> $userOrAccountClass | test | php | larastan/larastan | tests/Type/data/model.php | https://github.com/larastan/larastan/blob/master/tests/Type/data/model.php | MIT |
public function forget(string $key): self
{
$this->cache->forget($this->cachePrefix.$key);
return $this;
} | Forget the item from the cache.
@param string $key
@return CacheRepository | forget | php | ash-jc-allen/laravel-exchange-rates | src/Classes/CacheRepository.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/CacheRepository.php | MIT |
public function storeInCache(string $key, $value): bool
{
return $this->cache->forever($this->cachePrefix.$key, $value);
} | Store a new item in the cache.
@param string $key
@param string|array $value
@return bool | storeInCache | php | ash-jc-allen/laravel-exchange-rates | src/Classes/CacheRepository.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/CacheRepository.php | MIT |
public function getFromCache(string $key)
{
return $this->cache->get($this->cachePrefix.$key);
} | Get an item from the cache if it exists.
@param string $key
@return mixed
@throws InvalidArgumentException | getFromCache | php | ash-jc-allen/laravel-exchange-rates | src/Classes/CacheRepository.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/CacheRepository.php | MIT |
public function buildCacheKey(string $from, string|array $to, Carbon $date, ?Carbon $endDate = null): string
{
if (is_array($to)) {
asort($to);
$to = implode('_', $to);
}
$key = $from.'_'.$to.'_'.$date->format('Y-m-d');
if ($endDate) {
$key .= '_'.$endDate->format('Y-m-d');
}
return $key;
} | Build the key that can be used for fetching or
storing items in the cache. We can pass a
fourth parameter if we are storing
exchange rates for a given date
range.
@param string $from
@param string|string[] $to
@param Carbon $date
@param Carbon|null $endDate
@return string | buildCacheKey | php | ash-jc-allen/laravel-exchange-rates | src/Classes/CacheRepository.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/CacheRepository.php | MIT |
public function isAllowableCurrency(string $currency): bool
{
return in_array($currency, $this->allowableCurrencies, true);
} | Determine if a currency that is being used is allowable and supported by the API.
@param string $currency
@return bool | isAllowableCurrency | php | ash-jc-allen/laravel-exchange-rates | src/Classes/Currency.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/Currency.php | MIT |
public static function validateCurrencyCode(string $currencyCode): void
{
$currencies = new Currency();
if (! $currencies->isAllowableCurrency($currencyCode)) {
throw new InvalidCurrencyException($currencyCode.' is not a valid currency code.');
}
} | Validate that the currency is supported by the exchange rates API.
@param string $currencyCode
@throws InvalidCurrencyException | validateCurrencyCode | php | ash-jc-allen/laravel-exchange-rates | src/Classes/Validation.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/Validation.php | MIT |
public static function validateCurrencyCodes(array $currencyCodes): void
{
$currencies = new Currency();
foreach ($currencyCodes as $currencyCode) {
if (! $currencies->isAllowableCurrency($currencyCode)) {
throw new InvalidCurrencyException($currencyCode.' is not a valid currency code.');
}
}
} | Validate that the currencies are all supported by the exchange rates API.
@param array $currencyCodes
@throws InvalidCurrencyException | validateCurrencyCodes | php | ash-jc-allen/laravel-exchange-rates | src/Classes/Validation.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/Validation.php | MIT |
public static function validateStartAndEndDates(Carbon $from, Carbon $to): void
{
self::validateDate($from);
self::validateDate($to);
if ($from->isAfter($to)) {
throw new InvalidDateException('The \'from\' date must be before the \'to\' date.');
}
} | Validate that both of the dates are in the past. After this, check that
the 'from' date is not after the 'to' date.
@param Carbon $from
@param Carbon $to
@throws InvalidDateException | validateStartAndEndDates | php | ash-jc-allen/laravel-exchange-rates | src/Classes/Validation.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/Validation.php | MIT |
public static function validateDate(Carbon $date): void
{
if (! $date->isPast()) {
throw new InvalidDateException('The date must be in the past.');
}
} | Validate the date that has been passed is in the past.
@param Carbon $date
@throws InvalidDateException | validateDate | php | ash-jc-allen/laravel-exchange-rates | src/Classes/Validation.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Classes/Validation.php | MIT |
private function makeRequestForExchangeRates(string $from, string|array $to, Carbon $date, Carbon $endDate): array
{
$symbols = is_string($to) ? $to : implode(',', $to);
/** @var Response $result */
$result = $this->sharedDriverLogicHandler
->getRequestBuilder()
->makeRequest('/timeseries', [
'base' => $from,
'start_date' => $date->format('Y-m-d'),
'end_date' => $endDate->format('Y-m-d'),
'symbols' => $symbols,
]);
$conversions = $result->timeSeries();
foreach ($conversions as $rateDate => $rates) {
$ratesForDay = is_string($to)
? $rates[$to]
: $rates;
$conversions[$rateDate] = $ratesForDay;
}
ksort($conversions);
return $conversions;
} | Make a request to the exchange rates API to get the exchange rates between a
date range. If only one currency is being used, we flatten the array to
remove currency symbol before returning it.
@param string|string[] $to
@return array<string, float>|array<string, array<string, float>>
@throws RequestException | makeRequestForExchangeRates | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/CurrencyBeacon/CurrencyBeaconDriver.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/CurrencyBeacon/CurrencyBeaconDriver.php | MIT |
public function makeRequest(string $path, array $queryParams = []): ResponseContract
{
$protocol = config('laravel-exchange-rates.https') ? 'https://' : 'http://';
$rawResponse = Http::baseUrl($protocol.self::BASE_URL)
->get(
$path,
array_merge(['api_key' => $this->apiKey], $queryParams)
)
->throw()
->json();
return new Response($rawResponse);
} | Make an API request to the CurrencyBeacon API.
@param array<string, string> $queryParams
@throws RequestException | makeRequest | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/CurrencyBeacon/RequestBuilder.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/CurrencyBeacon/RequestBuilder.php | MIT |
private function makeRequestForExchangeRates(string $from, string|array $to, Carbon $date, Carbon $endDate): array
{
$symbols = is_string($to) ? $to : implode(',', $to);
$result = $this->sharedDriverLogicHandler
->getRequestBuilder()
->makeRequest('/timeframe', [
'source' => $from,
'start_date' => $date->format('Y-m-d'),
'end_date' => $endDate->format('Y-m-d'),
'currencies' => $symbols,
]);
$conversions = $result->rates();
foreach ($conversions as $rateDate => $rates) {
$ratesForDay = is_string($to)
? $rates[$from.$to]
: $this->removeSourceCurrencyFromKeys($rates);
$conversions[$rateDate] = $ratesForDay;
}
ksort($conversions);
return $conversions;
} | Make a request to the exchange rates API to get the exchange rates between a
date range. If only one currency is being used, we flatten the array to
remove currency symbol before returning it.
@param string $from
@param string|string[] $to
@param Carbon $date
@param Carbon $endDate
@return array<string, float>|array<string, array<string, float>>
@throws RequestException | makeRequestForExchangeRates | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/ExchangeRateHost/ExchangeRateHostDriver.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/ExchangeRateHost/ExchangeRateHostDriver.php | MIT |
private function removeSourceCurrencyFromKeys(array $rates): array
{
return collect($rates)
->mapWithKeys(static fn (float $value, string $key): array => [substr($key, 3) => $value])
->all();
} | The quotes are returned in the format of "USDEUR": 0.1234. We only want the
converted currency's code (e.g. EUR), so we need to remove the source
currency from the start of the key (e.g. USD). We can do this by
removing the first three characters from the key. Strip these
characters from all the rates and then return the array.
@param array<string,float> $rates
@return array<string,float> | removeSourceCurrencyFromKeys | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/ExchangeRateHost/ExchangeRateHostDriver.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/ExchangeRateHost/ExchangeRateHostDriver.php | MIT |
public function makeRequest(string $path, array $queryParams = []): ResponseContract
{
$protocol = config('laravel-exchange-rates.https') ? 'https://' : 'http://';
$rawResponse = Http::baseUrl($protocol.self::BASE_URL)
->get(
$path,
array_merge(['access_key' => $this->apiKey], $queryParams)
)
->throw()
->json();
return new Response($rawResponse);
} | Make an API request to the ExchangeRatesAPI.
@param string $path
@param array<string, string> $queryParams
@return ResponseContract
@throws RequestException | makeRequest | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/ExchangeRateHost/RequestBuilder.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/ExchangeRateHost/RequestBuilder.php | MIT |
public function makeRequest(string $path, array $queryParams = []): ResponseContract
{
$protocol = config('laravel-exchange-rates.https') ? 'https://' : 'http://';
$rawResponse = Http::baseUrl($protocol.self::BASE_URL)
->get(
$path,
array_merge(['access_key' => $this->apiKey], $queryParams)
)
->throw()
->json();
return new Response($rawResponse);
} | Make an API request to the ExchangeRatesAPI.
@param string $path
@param array<string, string> $queryParams
@return ResponseContract
@throws RequestException | makeRequest | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/ExchangeRatesApiIo/RequestBuilder.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/ExchangeRatesApiIo/RequestBuilder.php | MIT |
public function makeRequest(string $path, array $queryParams = []): ResponseContract
{
$protocol = config('laravel-exchange-rates.https') ? 'https://' : 'http://';
$rawResponse = Http::baseUrl($protocol.self::BASE_URL)
->withHeaders([
'apiKey' => $this->apiKey,
])
->get($path, $queryParams)
->throw()
->json();
return new Response($rawResponse);
} | Make an API request to the Exchange Rates Data API.
@param string $path
@param array<string, string> $queryParams
@return ResponseContract
@throws RequestException | makeRequest | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/ExchangeRatesDataApi/RequestBuilder.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/ExchangeRatesDataApi/RequestBuilder.php | MIT |
public function currencies(): array
{
$cacheKey = 'currencies';
if ($cachedExchangeRate = $this->attemptToResolveFromCache($cacheKey)) {
return $cachedExchangeRate;
}
$response = $this->requestBuilder->makeRequest('/latest', []);
$currencies = [$response->get('base')];
foreach ($response->rates() as $currency => $rate) {
$currencies[] = $currency;
}
if ($this->shouldCache) {
$this->cacheRepository->storeInCache($cacheKey, $currencies);
}
return $currencies;
} | Return an array of available currencies that can be used with this package.
@return string[]
@throws InvalidArgumentException
@throws RequestException | currencies | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function exchangeRate(string $from, string|array $to, ?Carbon $date = null): float|array
{
$this->validateExchangeRateInput($from, $to, $date);
if ($from === $to) {
return 1.0;
}
$cacheKey = $this->cacheRepository->buildCacheKey($from, $to, $date ?? Carbon::now());
if ($cachedExchangeRate = $this->attemptToResolveFromCache($cacheKey)) {
// If the exchange rate has been retrieved from the cache as a
// string (e.g. "1.23"), then cast it to a float (e.g. 1.23).
// If we have retrieved the rates for many currencies, it
// will be an array of floats, so just return it.
return is_string($cachedExchangeRate)
? (float) $cachedExchangeRate
: $cachedExchangeRate;
}
$symbols = is_string($to) ? $to : implode(',', $to);
$queryParams = ['base' => $from, 'symbols' => $symbols];
$url = $date
? '/'.$date->format('Y-m-d')
: '/latest';
$response = $this->requestBuilder->makeRequest($url, $queryParams)->rates();
$exchangeRate = is_string($to) ? $response[$to] : $response;
if ($this->shouldCache) {
$this->cacheRepository->storeInCache($cacheKey, $exchangeRate);
}
return $exchangeRate;
} | Return the exchange rate between the $from and $to parameters. If no $date
parameter is passed, we use today's date instead. If $to is a string,
the exchange rate will be returned as a string. If $to is an array,
the rates will be returned within an array.
@param string $from
@param string|string[] $to
@param Carbon|null $date
@return float|array<string, float>
@throws InvalidCurrencyException
@throws InvalidDateException
@throws RequestException
@throws InvalidArgumentException | exchangeRate | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function exchangeRateBetweenDateRange(
string $from,
string|array $to,
Carbon $date,
Carbon $endDate,
): array {
$this->validateExchangeRateBetweenDateRangeInput($from, $to, $date, $endDate);
$cacheKey = $this->cacheRepository->buildCacheKey($from, $to, $date, $endDate);
if ($cachedExchangeRate = $this->attemptToResolveFromCache($cacheKey)) {
return $cachedExchangeRate;
}
$conversions = $from === $to
? $this->exchangeRateDateRangeResultWithSameCurrency($date, $endDate)
: $this->makeRequestForExchangeRates($from, $to, $date, $endDate);
if ($this->shouldCache) {
$this->cacheRepository->storeInCache($cacheKey, $conversions);
}
return $conversions;
} | Return the exchange rates between the given date range.
@param string $from
@param string|string[] $to
@param Carbon $date
@param Carbon $endDate
@return array<string, float>|array<string, array<string, float>>
@throws InvalidCurrencyException
@throws InvalidDateException
@throws RequestException
@throws InvalidArgumentException | exchangeRateBetweenDateRange | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
private function makeRequestForExchangeRates(string $from, string|array $to, Carbon $date, Carbon $endDate): array
{
$symbols = is_string($to) ? $to : implode(',', $to);
$result = $this->requestBuilder->makeRequest('/timeseries', [
'base' => $from,
'start_date' => $date->format('Y-m-d'),
'end_date' => $endDate->format('Y-m-d'),
'symbols' => $symbols,
]);
$conversions = $result->rates();
if (is_string($to)) {
foreach ($conversions as $date => $rate) {
$conversions[$date] = $rate[$to];
}
}
ksort($conversions);
return $conversions;
} | Make a request to the exchange rates API to get the exchange rates between a
date range. If only one currency is being used, we flatten the array to
remove currency symbol before returning it.
@param string $from
@param string|string[] $to
@param Carbon $date
@param Carbon $endDate
@return array<string, float>|array<string, array<string, float>>
@throws RequestException | makeRequestForExchangeRates | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function convert(int $value, string $from, string|array $to, ?Carbon $date = null): float|array
{
return $this->convertUsingRates(
$this->exchangeRate($from, $to, $date),
$to,
$value,
);
} | Return the converted values between the $from and $to parameters. If no $date
parameter is passed, we use today's date instead.
@param int $value
@param string $from
@param string|string[] $to
@param Carbon|null $date
@return float|array<string, float>
@throws InvalidDateException
@throws InvalidCurrencyException
@throws RequestException
@throws InvalidArgumentException | convert | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function convertBetweenDateRange(
int $value,
string $from,
string|array $to,
Carbon $date,
Carbon $endDate,
): array {
return $this->convertUsingRatesForDateRange(
$this->exchangeRateBetweenDateRange($from, $to, $date, $endDate),
$to,
$value,
);
} | Return an array of the converted values between the given date range.
@param int $value
@param string $from
@param string|string[] $to
@param Carbon $date
@param Carbon $endDate
@return array<string, float>|array<string, array<string, float>>
@throws InvalidCurrencyException
@throws InvalidDateException
@throws RequestException
@throws InvalidArgumentException | convertBetweenDateRange | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function exchangeRateDateRangeResultWithSameCurrency(
Carbon $startDate,
Carbon $endDate,
): array {
$conversions = [];
for ($date = clone $startDate; $date->lte($endDate); $date->addDay()) {
if ($date->isWeekday()) {
$conversions[$date->format('Y-m-d')] = 1.0;
}
}
return $conversions;
} | If the 'from' and 'to' currencies are the same, we don't need to make a request to
the API. Instead, we can build the response ourselves to improve the performance.
@param Carbon $startDate
@param Carbon $endDate
@return array<string, float> | exchangeRateDateRangeResultWithSameCurrency | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function shouldCache(bool $shouldCache = true): self
{
$this->shouldCache = $shouldCache;
return $this;
} | Determine whether if the exchange rate should be cached after it is fetched
from the API.
@param bool $shouldCache
@return $this | shouldCache | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function shouldBustCache(bool $bustCache = true): self
{
$this->shouldBustCache = $bustCache;
return $this;
} | Determine whether if the cached result (if it exists) should be deleted. This
will force a new exchange rate to be fetched from the API.
@param bool $bustCache
@return $this | shouldBustCache | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function attemptToResolveFromCache(string $cacheKey): mixed
{
if ($this->shouldBustCache) {
$this->cacheRepository->forget($cacheKey);
$this->shouldBustCache = false;
} elseif ($cachedValue = $this->cacheRepository->getFromCache($cacheKey)) {
return $cachedValue;
}
return null;
} | Attempt to fetch an item (more than likely an exchange rate) from the cache.
If it exists, return it. If it has been specified, bust the cache.
@param string $cacheKey
@return mixed|null
@throws InvalidArgumentException | attemptToResolveFromCache | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function convertUsingRates(float|array $exchangeRates, string|array $to, int $value): float|array
{
if (is_string($to)) {
return (float) $exchangeRates * $value;
}
foreach ($exchangeRates as $currency => $exchangeRate) {
$exchangeRates[$currency] = (float) $exchangeRate * $value;
}
return $exchangeRates;
} | Use the exchange rates we've just retrieved and convert the given value.
@param float|array<string,float> $exchangeRates
@param string|string[] $to
@param int $value
@return float|array<string,float> | convertUsingRates | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function convertUsingRatesForDateRange(array $exchangeRates, string|array $to, int $value): array
{
$conversions = [];
if (is_array($to)) {
foreach ($exchangeRates as $date => $exchangeRate) {
foreach ($exchangeRate as $currency => $rate) {
$conversions[$date][$currency] = (float) $rate * $value;
}
}
return $conversions;
}
foreach ($exchangeRates as $date => $exchangeRate) {
$conversions[$date] = (float) $exchangeRate * $value;
}
return $conversions;
} | Use the exchange rates we've just retrieved and convert the given value
for each date in the date range.
@param array<string,float|array<string,float>> $exchangeRates
@param string|string[] $to
@param int $value
@return array<string,float|array<string,float>> | convertUsingRatesForDateRange | php | ash-jc-allen/laravel-exchange-rates | src/Drivers/Support/SharedDriverLogicHandler.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Drivers/Support/SharedDriverLogicHandler.php | MIT |
public function register(): void
{
$this->mergeConfigFrom(__DIR__.'/../../config/laravel-exchange-rates.php', 'laravel-exchange-rates');
$this->app->alias(ExchangeRate::class, 'exchange-rate');
} | Register any application services.
@return void | register | php | ash-jc-allen/laravel-exchange-rates | src/Providers/ExchangeRatesProvider.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Providers/ExchangeRatesProvider.php | MIT |
public function boot(): void
{
$this->publishes([
__DIR__.'/../../config/laravel-exchange-rates.php' => config_path('laravel-exchange-rates.php'),
], 'laravel-exchange-rates-config');
} | Bootstrap any application services.
@return void | boot | php | ash-jc-allen/laravel-exchange-rates | src/Providers/ExchangeRatesProvider.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Providers/ExchangeRatesProvider.php | MIT |
public function passes($attribute, $value): bool
{
return (new Currency())->isAllowableCurrency($value);
} | Determine if the validation rule passes.
@param string $attribute
@param mixed $value
@return bool | passes | php | ash-jc-allen/laravel-exchange-rates | src/Rules/ValidCurrency.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Rules/ValidCurrency.php | MIT |
public function message(): string
{
return 'The :attribute must be a valid exchange rates currency.';
} | Get the validation error message.
@return string | message | php | ash-jc-allen/laravel-exchange-rates | src/Rules/ValidCurrency.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/src/Rules/ValidCurrency.php | MIT |
protected function getPackageProviders($app)
{
return [ExchangeRatesProvider::class];
} | Load package service provider.
@param $app
@return array | getPackageProviders | php | ash-jc-allen/laravel-exchange-rates | tests/Unit/TestCase.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/tests/Unit/TestCase.php | MIT |
protected function getPackageAliases($app)
{
return [
'exchange-rates' => ExchangeRate::class,
];
} | Load package alias.
@param Application $app
@return array | getPackageAliases | php | ash-jc-allen/laravel-exchange-rates | tests/Unit/TestCase.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/tests/Unit/TestCase.php | MIT |
public function validator_returns_true_if_the_currency_is_valid(string $currency): void
{
$testData = [
'currency' => $currency,
];
$rules = [
'currency' => new ValidCurrency,
];
$validator = Validator::make($testData, $rules);
$this->assertFalse($validator->fails());
} | @test
@testWith ["GBP"]
["BYR"]
["BYN"]
["VES"] | validator_returns_true_if_the_currency_is_valid | php | ash-jc-allen/laravel-exchange-rates | tests/Unit/Rules/ValidCurrencyTest.php | https://github.com/ash-jc-allen/laravel-exchange-rates/blob/master/tests/Unit/Rules/ValidCurrencyTest.php | MIT |
public function handle($request, Closure $next)
{
if (! $this->isCorsRequest($request)) {
return $next($request);
}
$this->corsProfile->setRequest($request);
if (! $this->corsProfile->isAllowed()) {
return $this->forbiddenResponse();
}
if ($this->isPreflightRequest($request)) {
return $this->handlePreflightRequest();
}
$response = $next($request);
return $this->corsProfile->addCorsHeaders($response);
} | Handle an incoming request.
@param \Illuminate\Http\Request $request
@param \Closure $next
@return mixed | handle | php | spatie/laravel-cors | src/Cors.php | https://github.com/spatie/laravel-cors/blob/master/src/Cors.php | MIT |
protected function getPackageProviders($app)
{
return [
\Spatie\Cors\CorsServiceProvider::class,
];
} | @param \Illuminate\Foundation\Application $app
@return array | getPackageProviders | php | spatie/laravel-cors | tests/TestCase.php | https://github.com/spatie/laravel-cors/blob/master/tests/TestCase.php | MIT |
public function __construct($describers, $modelDescribers, ?CacheItemPoolInterface $cacheItemPool = null, ?string $cacheItemId = null, ?Generator $generator = null)
{
$this->describers = $describers;
$this->modelDescribers = $modelDescribers;
$this->cacheItemPool = $cacheItemPool;
$this->cacheItemId = $cacheItemId ?? 'openapi_doc';
$this->generator = $generator ?? new Generator($this->logger);
} | @param DescriberInterface[]|iterable $describers
@param ModelDescriberInterface[]|iterable $modelDescribers | __construct | php | nelmio/NelmioApiDocBundle | src/ApiDocGenerator.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/ApiDocGenerator.php | MIT |
public function getPath(): string
{
if (!isset($this->path)) {
$reflected = new \ReflectionObject($this);
// assume the modern directory structure by default
$this->path = \dirname($reflected->getFileName(), 2);
}
return $this->path;
} | Allows using the new directory structure on Symfony < 6.1.
Without this no proper namespace is set for twig templates.
@see \Symfony\Component\HttpKernel\Bundle\AbstractBundle::getPath() | getPath | php | nelmio/NelmioApiDocBundle | src/NelmioApiDocBundle.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/NelmioApiDocBundle.php | MIT |
public function __construct(
array $properties = [],
string $type = Generator::UNDEFINED,
?array $groups = null,
array $options = [],
array $serializationContext = [],
) {
parent::__construct($properties + [
'type' => $type,
'groups' => $groups,
'options' => $options,
'serializationContext' => $serializationContext,
]);
} | @param mixed[] $properties
@param string[] $groups
@param mixed[] $options
@param array<string, mixed> $serializationContext | __construct | php | nelmio/NelmioApiDocBundle | src/Attribute/Model.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/Attribute/Model.php | MIT |
public function __construct(
array $properties = [],
?string $name = null,
array $scopes = [],
) {
parent::__construct($properties + [
'name' => $name,
'scopes' => $scopes,
]);
} | @param array<string, mixed> $properties
@param string[] $scopes | __construct | php | nelmio/NelmioApiDocBundle | src/Attribute/Security.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/Attribute/Security.php | MIT |
private function findNameAliases(array $names, string $area): array
{
$nameAliases = array_filter($names, function (array $aliasInfo) use ($area) {
return [] === $aliasInfo['areas'] || \in_array($area, $aliasInfo['areas'], true);
});
$aliases = [];
foreach ($nameAliases as $nameAlias) {
$aliases[$nameAlias['alias']] = [
'type' => $nameAlias['type'],
'groups' => $nameAlias['groups'],
'options' => $nameAlias['options'],
'serializationContext' => $nameAlias['serializationContext'],
];
}
return $aliases;
} | @param array<int, mixed> $names
@return array<string, mixed> | findNameAliases | php | nelmio/NelmioApiDocBundle | src/DependencyInjection/NelmioApiDocExtension.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/DependencyInjection/NelmioApiDocExtension.php | MIT |
public function process(ContainerBuilder $container): void
{
// Find the OpenAPI generator service.
$definition = $container->findDefinition('nelmio_api_doc.open_api.generator');
foreach ($this->findAndSortTaggedServices('nelmio_api_doc.swagger.processor', $container) as $reference) {
$tags = $container->findDefinition((string) $reference)->getTag('nelmio_api_doc.swagger.processor');
// See if the processor has a 'before' attribute.
$before = null;
foreach ($tags as $tag) {
if (isset($tag['before'])) {
$before = $tag['before'];
}
}
$definition->addMethodCall('addNelmioProcessor', [$reference, $before]);
}
} | Process services tagged as 'swagger.processor'.
@param ContainerBuilder $container The container builder | process | php | nelmio/NelmioApiDocBundle | src/DependencyInjection/Compiler/CustomProcessorPass.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/DependencyInjection/Compiler/CustomProcessorPass.php | MIT |
public function __construct($externalDoc, bool $overwrite = false)
{
$this->externalDoc = $externalDoc;
$this->overwrite = $overwrite;
} | @param array<string, mixed>|callable $externalDoc | __construct | php | nelmio/NelmioApiDocBundle | src/Describer/ExternalDocDescriber.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/Describer/ExternalDocDescriber.php | MIT |
private function getAttributesAsAnnotation($reflection, \OpenApi\Context $context): array
{
$attributesFactory = new AttributeAnnotationFactory();
$attributes = $attributesFactory->build($reflection, $context);
// The attributes factory removes the context after executing so we need to set it back...
$this->setContext($context);
return $attributes;
} | @param \ReflectionClass<object>|\ReflectionMethod $reflection
@return OA\AbstractAnnotation[] | getAttributesAsAnnotation | php | nelmio/NelmioApiDocBundle | src/Describer/OpenApiPhpDescriber.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/Describer/OpenApiPhpDescriber.php | MIT |
public function __construct(
array $securitySchemes,
RouteCollection $routeCollection,
ControllerReflector $controllerReflector
) {
$this->securitySchemes = $securitySchemes;
$this->routeCollection = $routeCollection;
$this->controllerReflector = $controllerReflector;
} | @param array<string, array<string, mixed>> $securitySchemes | __construct | php | nelmio/NelmioApiDocBundle | src/Describer/SecurityDescriber.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/Describer/SecurityDescriber.php | MIT |
private static function transformSecurityScheme(array $securityScheme): array
{
// Ensure Flow get transformed to the proper class variant
if (isset($securityScheme['flows'])) {
$flows = [];
foreach ($securityScheme['flows'] as $flow => $flowProperties) {
$flows[] = new OA\Flow($flowProperties + ['flow' => $flow]);
}
$securityScheme['flows'] = $flows;
}
return $securityScheme;
} | @param array<string, mixed> $securityScheme
@return array<string, mixed> | transformSecurityScheme | php | nelmio/NelmioApiDocBundle | src/Describer/SecurityDescriber.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/Describer/SecurityDescriber.php | MIT |
public function __construct(Type $type, ?array $groups = null, array $options = [], array $serializationContext = [])
{
$this->type = $type;
$this->options = $options;
$this->serializationContext = $serializationContext;
if (null !== $groups) {
$this->serializationContext['groups'] = $groups;
}
} | @param string[]|null $groups
@param mixed[] $options
@param mixed[] $serializationContext | __construct | php | nelmio/NelmioApiDocBundle | src/Model/Model.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/Model/Model.php | MIT |
public function __construct($modelDescribers, OA\OpenApi $api, array $alternativeNames = [])
{
$this->modelDescribers = $modelDescribers;
$this->api = $api;
$this->logger = new NullLogger();
foreach (array_reverse($alternativeNames) as $alternativeName => $criteria) {
$this->alternativeNames[] = $model = new Model(
new Type('object', false, $criteria['type']),
$criteria['groups'],
$criteria['options'] ?? [],
$criteria['serializationContext'] ?? [],
);
$this->names[$model->getHash()] = $alternativeName;
$this->registeredModelNames[$alternativeName] = $model;
Util::getSchema($this->api, $alternativeName);
}
} | @param ModelDescriberInterface[]|iterable $modelDescribers
@param array<string, mixed> $alternativeNames
@internal | __construct | php | nelmio/NelmioApiDocBundle | src/Model/ModelRegistry.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/Model/ModelRegistry.php | MIT |
protected function applyOpenApiDiscriminator(
Model $model,
OA\Schema $schema,
ModelRegistry $modelRegistry,
string $discriminatorProperty,
array $typeMap,
): void {
$weakContext = Util::createWeakContext($schema->_context);
$schema->oneOf = [];
$schema->discriminator = new OA\Discriminator(['_context' => $weakContext]);
$schema->discriminator->propertyName = $discriminatorProperty;
$schema->discriminator->mapping = [];
foreach ($typeMap as $propertyValue => $className) {
$oneOfSchema = new OA\Schema(['_context' => $weakContext]);
$oneOfSchema->ref = $modelRegistry->register(new Model(
new Type(Type::BUILTIN_TYPE_OBJECT, false, $className),
$model->getGroups(),
$model->getOptions(),
$model->getSerializationContext()
));
$schema->oneOf[] = $oneOfSchema;
$schema->discriminator->mapping[$propertyValue] = $oneOfSchema->ref;
}
} | @param Model $model the model that's being described, This is used to pass groups and config
down to the children models in `oneOf`
@param OA\Schema $schema The Open API schema to which `oneOf` and `discriminator` properties
will be added
@param string $discriminatorProperty The property that determine which model will be unsierailized
@param array<string, string> $typeMap the map of $discriminatorProperty values to their
types | applyOpenApiDiscriminator | php | nelmio/NelmioApiDocBundle | src/ModelDescriber/ApplyOpenApiDiscriminatorTrait.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/ModelDescriber/ApplyOpenApiDiscriminatorTrait.php | MIT |
private function findFormType(FormConfigInterface $config, OA\Schema $property): void
{
$type = $config->getType();
if (null === $builtinFormType = $this->getBuiltinFormType($type)) {
// if form type is not builtin in Form component.
$model = new Model(
new Type(Type::BUILTIN_TYPE_OBJECT, false, \get_class($type->getInnerType())),
null,
$config->getOptions()
);
$ref = $this->modelRegistry->register($model);
// We need to use allOf for description and title to be displayed
if ($config->hasOption('documentation') && [] !== $config->getOption('documentation')) {
$property->oneOf = [new OA\Schema(['ref' => $ref])];
} else {
$property->ref = $ref;
}
return;
}
do {
$blockPrefix = $builtinFormType->getBlockPrefix();
if ('text' === $blockPrefix) {
$property->type = 'string';
break;
}
if ('number' === $blockPrefix) {
$property->type = 'number';
break;
}
if ('integer' === $blockPrefix) {
$property->type = 'integer';
break;
}
if ('date' === $blockPrefix) {
$property->type = 'string';
$property->format = 'date';
break;
}
if ('datetime' === $blockPrefix) {
$property->type = 'string';
$property->format = 'date-time';
break;
}
if ('choice' === $blockPrefix) {
if (true === $config->getOption('multiple')) {
$property->type = 'array';
} else {
$property->type = 'string';
}
if ([] !== $choices = $config->getOption('choices')) {
$enums = array_values($choices);
if ($this->isNumbersArray($enums)) {
$type = 'number';
} elseif ($this->isBooleansArray($enums)) {
$type = 'boolean';
} else {
$type = 'string';
}
if (true === $config->getOption('multiple')) {
$property->items = Util::createChild($property, OA\Items::class, ['type' => $type, 'enum' => $enums]);
} else {
$property->type = $type;
$property->enum = $enums;
}
}
break;
}
if ('checkbox' === $blockPrefix) {
$property->type = 'boolean';
break;
}
if ('password' === $blockPrefix) {
$property->type = 'string';
$property->format = 'password';
break;
}
if ('repeated' === $blockPrefix) {
$property->type = 'object';
$property->required = [$config->getOption('first_name'), $config->getOption('second_name')];
$subType = $config->getOption('type');
foreach (['first', 'second'] as $subField) {
$subName = $config->getOption($subField.'_name');
$subForm = $this->formFactory->create($subType, null, array_merge($config->getOption('options'), $config->getOption($subField.'_options')));
$this->findFormType($subForm->getConfig(), Util::getProperty($property, $subName));
}
break;
}
if ('collection' === $blockPrefix) {
$subType = $config->getOption('entry_type');
$subOptions = $config->getOption('entry_options');
$subForm = $this->formFactory->create($subType, null, $subOptions);
$property->type = 'array';
$property->items = Util::createChild($property, OA\Items::class);
$this->findFormType($subForm->getConfig(), $property->items);
break;
}
// The DocumentType is bundled with the DoctrineMongoDBBundle
if ('entity' === $blockPrefix || 'document' === $blockPrefix) {
$entityClass = $config->getOption('class');
if (true === $config->getOption('multiple')) {
$property->format = \sprintf('[%s id]', $entityClass);
$property->type = 'array';
$property->items = Util::createChild($property, OA\Items::class, ['type' => 'string']);
} else {
$property->type = 'string';
$property->format = \sprintf('%s id', $entityClass);
}
break;
}
} while ($builtinFormType = $builtinFormType->getParent());
} | Finds and sets the schema type on $property based on $config info. | findFormType | php | nelmio/NelmioApiDocBundle | src/ModelDescriber/FormModelDescriber.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/ModelDescriber/FormModelDescriber.php | MIT |
private function isNumbersArray(array $array): bool
{
foreach ($array as $item) {
if (!is_numeric($item)) {
return false;
}
}
return true;
} | @param mixed[] $array
@return bool true if $array contains only numbers, false otherwise | isNumbersArray | php | nelmio/NelmioApiDocBundle | src/ModelDescriber/FormModelDescriber.php | https://github.com/nelmio/NelmioApiDocBundle/blob/master/src/ModelDescriber/FormModelDescriber.php | MIT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.