From c78e4a1c554b6cd2f80f55ed76458fa657e23c8d Mon Sep 17 00:00:00 2001 From: Adiel Cristo Date: Mon, 19 Aug 2024 10:57:44 -0300 Subject: [PATCH] Translate file releases.md Issue: GH-39 --- prologo/versoes.md | 421 +++++++++++++++++++++++++-------------------- 1 file changed, 237 insertions(+), 184 deletions(-) diff --git a/prologo/versoes.md b/prologo/versoes.md index 3f8885c..5bba7ca 100644 --- a/prologo/versoes.md +++ b/prologo/versoes.md @@ -16,7 +16,7 @@ O esquema de versionamento do Laravel mantém a seguinte convenção: `paradigm.major.minor`. As versões maiores do _framework_ são lançadas a cada seis meses (em fevereiro e agosto), enquanto as versões menores podem ser lançadas semanalmente. -Versões menores e de correções **nunca** devem conter alterações significativas. +Versões menores **nunca** devem conter alterações significativas. Ao referenciar o _framework_ Laravel e seus componentes a partir da sua aplicação ou pacote, você deve sempre usar uma restrição de versão como @@ -58,10 +58,10 @@ O Laravel 5.8 continua as melhorias feitas no Laravel 5.7, introduzindo relacionamentos `hasOneThrough` do Eloquent, validação de _e-mail_ aprimorada, registro automático de políticas de autorização baseado em convenção, _cache_ e _drivers_ de sessão do DynamoDB, configuração aprimorada de fuso horário do -agendador, suporte a atribuição de vários guardas de autenticação para canais de -transmissão, conformidade do _driver_ de _cache_ com a PSR-16, melhorias no -comando `artisan serve`, suporte ao PHPUnit, suporte ao Carbon 2.0, suporte ao -Pheanstalk 4.0 e uma variedade de outras correções de falhas e melhorias de +agendador, suporte a atribuição de múltiplas proteções de autenticação para +canais de transmissão, conformidade do _driver_ de _cache_ PSR-16, melhorias no +comando `artisan serve`, suporte ao PHPUnit 8.0, suporte ao Carbon 2.0, suporte +ao Pheanstalk 4.0 e uma variedade de outras correções de falhas e melhorias de usabilidade. ### Relacionamento `hasOneThrough` do Eloquent @@ -82,247 +82,300 @@ public function accountHistory() } ``` -### Auto-Discovery Of Model Policies +### Descoberta Automática de Políticas de Modelo -When using Laravel 5.7, each model's -corresponding [authorization policy](authorization.md#creating-policies) needed -to be explicitly registered in your application's `AuthServiceProvider`: +Ao usar o Laravel 5.7, a +[política de autorização](../authorization.md#creating-policies) de cada modelo +precisava ser explicitamente registrada no `AuthServiceProvider` da sua +aplicação: - /** - * The policy mappings for the application. - * - * @var array - */ - protected $policies = [ - 'App\User' => 'App\Policies\UserPolicy', - ]; - -Laravel 5.8 introduces auto-discovery of model policies as long as the model and -policy follow standard Laravel naming conventions. Specifically, the policies -must be in a `Policies` directory below the directory that contains the models. -So, for example, the models may be placed in the `app` directory while the -policies may be placed in the `app/Policies` directory. In addition, the policy -name must match the model name and have a `Policy` suffix. So, a `User` model -would correspond to a `UserPolicy` class. - -If you would like to provide your own policy discovery logic, you may register a -custom callback using the `Gate::guessPolicyNamesUsing` method. Typically, this -method should be called from your application's `AuthServiceProvider`: +```php +/** + * Os mapeamentos de políticas de autorização da aplicação. + * + * @var array + */ +protected $policies = [ + 'App\User' => 'App\Policies\UserPolicy', +]; +``` +O Laravel 5.8 introduz a descoberta automática de políticas de modelo, desde que +o modelo e a política sigam as convenções de nomenclatura padrão do Laravel. +Especificamente, as políticas devem estar em um diretório `Policies` abaixo do +diretório que contém os modelos. +Assim, por exemplo, os modelos podem ser colocados no diretório `app` enquanto +as políticas podem ser colocadas no diretório `app/Policies`. +Além disso, o nome da política deve corresponder ao nome do modelo e ter um +sufixo `Policy`. +Portanto, um modelo `User` corresponderia a uma classe `UserPolicy`. + +Se desejar fornecer sua própria lógica de descoberta de política, você pode +registrar um retorno de chamada personalizado usando o método +`Gate::guessPolicyNamesUsing`. +Normalmente, esse método deve ser chamado do `AuthServiceProvider` da sua +aplicação: + +```php use Illuminate\Support\Facades\Gate; Gate::guessPolicyNamesUsing(function ($modelClass) { - // return policy class name... + // Retorna o nome da classe da política de autorização... }); +``` -> {note} Any policies that are explicitly mapped in your `AuthServiceProvider` -> will take precedence over any potential auto-discovered policies. - -### PSR-16 Cache Compliance +> **Nota:** +> Quaisquer políticas mapeadas explicitamente em seu `AuthServiceProvider` terão +> precedência sobre quaisquer potenciais políticas descobertas automaticamente. -In order to allow a more granular expiration time when storing items and provide -compliance with the PSR-16 caching standard, the cache item time-to-live has -changed from minutes to seconds. The `put`, `putMany`, `add`, `remember` -and `setDefaultCacheTime` methods of the `Illuminate\Cache\Repository` class and -its extended classes, as well as the `put` method of each cache store were -updated with this changed behavior. -See [the related PR](https://github.com/laravel/framework/pull/27276) for more -info. +### Conformidade com o _Cache_ PSR-16 -If you are passing an integer to any of these methods, you should update your -code to ensure you are now passing the number of seconds you wish the item to -remain in the cache. Alternatively, you may pass a `DateTime` instance -indicating when the item should expire: +Para permitir um tempo de expiração mais granular ao armazenar itens e fornecer +conformidade com o padrão de _cache_ PSR-16, o tempo de vida do item de _cache_ +mudou de minutos para segundos. +Os métodos `put`, `putMany`, `add`, `remember` e `setDefaultCacheTime` da classe +`Illuminate\Cache\Repository` e suas classes estendidas, bem como o método `put` +de cada armazenamento de _cache_ foram atualizados com esta mudança de +comportamento. +Consulte o [PR relacionado](https://github.com/laravel/framework/pull/27276) +para obter mais informações. - // Laravel 5.7 - Store item for 30 minutes... - Cache::put('foo', 'bar', 30); +Se você estiver passando um número inteiro para qualquer um desses métodos, +deverá atualizar seu código para garantir que agora está passando o número de +segundos que deseja que o item permaneça no _cache_. +Alternativamente, você pode passar uma instância de `DateTime` indicando quando +o item deve expirar: - // Laravel 5.8 - Store item for 30 seconds... - Cache::put('foo', 'bar', 30); +```php +// Laravel 5.7 - Armazena item por 30 minutos... +Cache::put('foo', 'bar', 30); - // Laravel 5.7 / 5.8 - Store item for 30 seconds... - Cache::put('foo', 'bar', now()->addSeconds(30)); +// Laravel 5.8 - Armazena item por 30 segundos... +Cache::put('foo', 'bar', 30); -### Multiple Broadcast Authentication Guards +// Laravel 5.7 / 5.8 - Armazena item por 30 segundos... +Cache::put('foo', 'bar', now()->addSeconds(30)); +``` -In previous releases of Laravel, private and presence broadcast channels -authenticated the user via your application's default authentication guard. -Beginning in Laravel 5.8, you may now assign multiple guards that should -authenticate the incoming request: +### Múltiplas Proteções de Autenticação de Transmissão - Broadcast::channel('channel', function() { - // ... - }, ['guards' => ['web', 'admin']]) +Nas versões anteriores do Laravel, os canais de transmissão privados e de +presença autenticavam a pessoa usuária através da proteção de autenticação +padrão da sua aplicação. +A partir do Laravel 5.8, agora você pode atribuir múltiplas proteções que devem +autenticar a solicitação recebida: -### Token Guard Token Hashing +```php +Broadcast::channel('channel', function() { + // ... +}, ['guards' => ['web', 'admin']]) +``` -Laravel's `token` guard, which provides basic API authentication, now supports -storing API tokens as SHA-256 hashes. This provides improved security over -storing plain-text tokens. To learn more about hashed tokens, please review the -full [API authentication documentation](api-authentication.md). +### Criação do _Hash_ do _Token_ da Proteção `token` -> **Note:** While Laravel ships with a simple, token based authentication guard, -> we strongly recommend you consider using [Laravel Passport](passport.md) for -> robust, production applications that offer API authentication. +A proteção `token` do Laravel, que fornece autenticação básica de API, agora +suporta o armazenamento de _tokens_ de API como _hashes_ SHA-256. +Isso fornece segurança aprimorada em relação ao armazenamento de _tokens_ como +texto simples. +Para saber mais sobre _tokens_ com _hash_, revise a +[documentação completa da autenticação de API](../api-authentication.md). -### Improved Email Validation +> **Nota:** +> Embora o Laravel venha com uma proteção de autenticação simples baseada em +> _token_, recomendamos fortemente que você considere usar o +> [Laravel Passport](../passport.md) para aplicações de produção robustas que +> oferecem autenticação de API. -Laravel 5.8 introduces improvements to the validator's underlying email -validation logic by adopting the `egulias/email-validator` package utilized by -SwiftMailer. Laravel's previous email validation logic occasionally considered -valid emails, such as `example@bär.se`, to be invalid. +### Validação de _E-mail_ Aprimorada -### Default Scheduler Timezone +O Laravel 5.8 introduz melhorias na lógica de validação de _e-mail_ subjacente +do validador, adotando o pacote `egulias/email-validator` utilizado pelo +SwiftMailer. +A lógica de validação de _e-mail_ anterior do Laravel ocasionalmente considerava +_e-mails_ válidos, como `example@bär.se`, como inválidos. -Laravel allows you to customize the timezone of a scheduled task using -the `timezone` method: +### Fuso Horário Padrão do Agendador - $schedule->command('inspire') - ->hourly() - ->timezone('America/Chicago'); +O Laravel permite que você personalize o fuso horário de uma tarefa agendada +usando o método `timezone`: -However, this can become cumbersome and repetitive if you are specifying the -same timezone for all of your scheduled tasks. For that reason, you may now -define a `scheduleTimezone` method in your `app/Console/Kernel.php` file. This -method should return the default timezone that should be assigned to all -scheduled tasks: +```php +$schedule->command('inspire') + ->hourly() + ->timezone('America/Chicago'); +``` - /** - * Get the timezone that should be used by default for scheduled events. - * - * @return \DateTimeZone|string|null - */ - protected function scheduleTimezone() - { - return 'America/Chicago'; - } +No entanto, isso pode se tornar complicado e repetitivo se você especificar o +mesmo fuso horário para todas as tarefas agendadas. +Por esse motivo, agora você pode definir um método `scheduleTimezone` no seu +arquivo `app/Console/Kernel.php`. +Este método deve retornar o fuso horário padrão que deve ser atribuído a todas +as tarefas agendadas: -### Intermediate Table / Pivot Model Events +```php +/** + * Obtém o fuso horário que deve ser usado por padrão para eventos agendados. + * + * @return \DateTimeZone|string|null + */ +protected function scheduleTimezone() +{ + return 'America/Chicago'; +} +``` -In previous versions of Laravel, [Eloquent model events](eloquent.md#events) -were not dispatched when attaching, detaching, or syncing custom intermediate -table / "pivot" models of a many-to-many relationship. When -using [custom intermediate table models](eloquent-relationships.md#defining-custom-intermediate-table-models) -in Laravel 5.8, the applicable model events will now be dispatched. +### Eventos de Modelo de Tabela Intermediária / Pivô -### Artisan Call Improvements +Nas versões anteriores do Laravel, os +[eventos dos modelos do Eloquent](../eloquent.md#events) não eram despachados ao +anexar, desanexar ou sincronizar modelos de tabelas intermediárias / "pivôs" +personalizadas de um relacionamento muitos para muitos. +Ao usar +[modelos de tabela intermediária customizados](../eloquent-relationships.md#defining-custom-intermediate-table-models) +no Laravel 5.8, os eventos de modelo aplicáveis agora serão despachados. -Laravel allows you to invoke Artisan via the `Artisan::call` method. In previous -releases of Laravel, the command's options are passed via an array as the second -argument to the method: +### Melhorias no Método `Artisan::call` - use Illuminate\Support\Facades\Artisan; +O Laravel permite que você invoque o Artisan através do método `Artisan::call`. +Nas versões anteriores do Laravel, as opções do comando são passadas usando um +_array_ como segundo argumento do método: - Artisan::call('migrate:install', ['database' => 'foo']); +```php +use Illuminate\Support\Facades\Artisan; -However, Laravel 5.8 allows you to pass the entire command, including options, -as the first string argument to the method: +Artisan::call('migrate:install', ['database' => 'foo']); +``` - Artisan::call('migrate:install --database=foo'); +No entanto, o Laravel 5.8 permite que você passe o comando inteiro, incluindo +as opções, como uma _string_ no primeiro argumento do método: -### Mock / Spy Testing Helper Methods +```php +Artisan::call('migrate:install --database=foo'); +``` -In order to make mocking objects more convenient, new `mock` and `spy` methods -have been added to the base Laravel test case class. These methods automatically -bind the mocked class into the container. For example: +### Métodos Auxiliares de Testes `mock` e `spy` - // Laravel 5.7 - $this->instance(Service::class, Mockery::mock(Service::class, function ($mock) { - $mock->shouldReceive('process')->once(); - })); +Para tornar os objetos de simulação mais convenientes, novos métodos `mock` e +`spy` foram adicionados à classe base do caso de teste do Laravel. +Esses métodos vinculam automaticamente a classe simulada ao contêiner. +Por exemplo: - // Laravel 5.8 - $this->mock(Service::class, function ($mock) { - $mock->shouldReceive('process')->once(); - }); +```php +// Laravel 5.7 +$this->instance(Service::class, Mockery::mock(Service::class, function ($mock) { + $mock->shouldReceive('process')->once(); +})); + +// Laravel 5.8 +$this->mock(Service::class, function ($mock) { + $mock->shouldReceive('process')->once(); +}); +``` -### Eloquent Resource Key Preservation +### Preservação da Chave de Recurso do Eloquent -When returning an [Eloquent resource collection](eloquent-resources.md) from a -route, Laravel resets the collection's keys so that they are in simple numerical -order: +Ao retornar uma [coleção de recursos do Eloquent](../eloquent-resources.md) de +uma rota, o Laravel redefine as chaves da coleção para ficarem em ordem numérica +simples: - use App\User; - use App\Http\Resources\User as UserResource; +```php +use App\User; +use App\Http\Resources\User as UserResource; - Route::get('/user', function () { - return UserResource::collection(User::all()); - }); +Route::get('/user', function () { + return UserResource::collection(User::all()); +}); +``` -When using Laravel 5.8, you may now add a `preserveKeys` property to your -resource class indicating if collection keys should be preserved. By default, -and to maintain consistency with previous Laravel releases, the keys will be -reset by default: +Ao usar o Laravel 5.8, agora você pode adicionar uma propriedade `preserveKeys` +à sua classe de recurso indicando se as chaves da coleção devem ser preservadas. +Por padrão, e para manter a consistência com versões anteriores do Laravel, as +chaves serão redefinidas por padrão: - keyBy->id); - }); +Route::get('/user', function () { + return UserResource::collection(User::all()->keyBy->id); +}); +``` -### Higher Order `orWhere` Eloquent Method +### Método `orWhere` do Eloquent de Ordem Superior -In previous releases of Laravel, combining multiple Eloquent model scopes via -an `or` query operator required the use of Closure callbacks: +Nas versões anteriores do Laravel, a combinação de vários escopos de modelo do +Eloquent por meio de um operador de consulta `or` exigia o uso de retornos de +chamada de _closure_: - // scopePopular and scopeActive methods defined on the User model... - $users = App\User::popular()->orWhere(function (Builder $query) { - $query->active(); - })->get(); +```php +// Métodos scopePopular e scopeActive definidos no modelo User... +$users = App\User::popular()->orWhere(function (Builder $query) { + $query->active(); +})->get(); +``` -Laravel 5.8 introduces a "higher order" `orWhere` method that allows you to -fluently chain these scopes together without the use of Closures: +O Laravel 5.8 introduz um método `orWhere` de "ordem superior" que permite +encadear fluentemente esses escopos sem o uso de _closures_: - $users = App\User::popular()->orWhere->active()->get(); +```php +$users = App\User::popular()->orWhere->active()->get(); +``` -### Artisan Serve Improvements +### Melhorias no Comando `serve` do Artisan -In previous releases of Laravel, Artisan's `serve` command would serve your -application on port `8000`. If another `serve` command process was already -listening on this port, an attempt to serve a second application via `serve` -would fail. Beginning in Laravel 5.8, `serve` will now scan for available ports -up to port `8009`, allowing you to serve multiple applications at once. +Nas versões anteriores do Laravel, o comando `serve` do Artisan serviria sua +aplicação na porta `8000`. +Se outro processo do comando `serve` já estivesse escutando nesta porta, uma +tentativa de servir uma segunda aplicação via `serve` falharia. +A partir do Laravel 5.8, o `serve` agora irá procurar portas disponíveis até a +porta `8009`, permitindo que você atenda várias aplicações simultaneamente. -### Blade File Mapping +### Mapeamento de Arquivos do Blade -When compiling Blade templates, Laravel now adds a comment to the top of the -compiled file which contains the path to the original Blade template. +Ao compilar modelos do Blade, o Laravel agora adiciona um comentário no topo do +arquivo compilado que contém o caminho para o modelo original do Blade. -### DynamoDB Cache / Session Drivers +### _Drivers_ de _Cache_ e Sessão do DynamoDB -Laravel 5.8 introduces [DynamoDB](https://aws.amazon.com/dynamodb/) cache and -session drivers. DynamoDB is a serverless NoSQL database provided by Amazon Web -Services. The default configuration for the `dynamodb` cache driver can be found -in the Laravel -5.8 [cache configuration file](https://github.com/laravel/laravel/blob/master/config/cache.php). +O Laravel 5.8 introduz os _drivers_ de _cache_ e sessão do +[DynamoDB](https://aws.amazon.com/dynamodb/). +O DynamoDB é um banco de dados NoSQL sem servidor fornecido pela Amazon Web +Services. +A configuração padrão para o _driver_ de _cache_ `dynamodb` pode ser encontrada +no +[arquivo de configuração de +_cache_](https://github.com/laravel/laravel/blob/5.8/config/cache.php) +do Laravel 5.8. -### Carbon 2.0 Support +### Suporte para a Carbon 2.0 -Laravel 5.8 provides support for the `~2.0` release of the Carbon date -manipulation library. +O Laravel 5.8 fornece suporte para a versão `~2.0` da biblioteca de manipulação +de datas Carbon. -### Pheanstalk 4.0 Support +### Suporte para a Pheanstalk 4.0 -Laravel 5.8 provides support for the `~4.0` release of the Pheanstalk queue -library. If you are using Pheanstalk library in your application, please upgrade -your library to the `~4.0` release via Composer. +O Laravel 5.8 fornece suporte para a versão `~4.0` da biblioteca de filas +Pheanstalk. +Se você estiver usando a biblioteca Pheanstalk na sua aplicação, atualize sua +biblioteca para a versão `~4.0` via Composer.