Update composer.json

composer.json

@@ -8,7 +8,7 @@
         "orm",
         "migrations"
     ],
-    "homepage": "http://www.yiiframework.com/",
+    "homepage": "https://www.yiiframework.com/",
     "license": "BSD-3-Clause",
     "support": {
         "issues": "https://github.com/yiisoft/yii-cycle/issues?state=open",

docs/guide/en/installation.md

@@ -11,7 +11,6 @@ composer require yiisoft/yii-cycle
 If you use Yii with `composer-config-plugin`, Yii-Cycle settings could be specified in `config/params.php`:
 
 ```php
-<?php
 use Cycle\Schema\Generator;
 use Cycle\Schema\Provider\FromFilesSchemaProvider;
 use Cycle\Schema\Provider\SimpleCacheSchemaProvider;

docs/guide/en/reading-schema.md

@@ -7,11 +7,11 @@ Since a schema is built from an array of a certain structure, we can store it ei
 You can display currently used schema by executing `cycle/schema` command.
 
 In `yii-cycle` package schema can be built from multiple sources represented by multiple providers implementing
-`Cycle\Schema\Provider\SchemaProviderInterface`. 
+`Cycle\Schema\Provider\SchemaProviderInterface`.
 
 In order to use multiple schema providers in turn, grouping `Cycle\Schema\Provider\Support\SchemaProviderPipeline`
 provider is used. You can configure this provider in `schema-providers` section of a `config/params.php` file.
-Arrage schema providers in such an order, that caching providers are at the top of the list, 
+Arrage schema providers in such an order, that caching providers are at the top of the list,
 and origin schema providers at the end.
 
 ## Entity attributes based schema
@@ -75,11 +75,11 @@ return [
 ];
 ```
 
-Note that: 
+Note that:
 
 1. `FromFilesSchemaProvider` loads a schema from PHP-files via `include`. That requires security precautions.
    Make sure you store schema file in a safe path restricted from users.
-2. You can specify multiple schema files, which will be merged into one schema. 
+2. You can specify multiple schema files, which will be merged into one schema.
 Exception will be thrown in case of collision of roles.
 
 3. Thanks to internal cache, loading schema from a PHP-file is so fast that you can skip an external cache at all.
@@ -122,7 +122,6 @@ return [
 In order to export schema as PHP file `cycle/schema/php` command could be used.
 Specify a file name as an argument and schema will be written into it:
 
-
 ```bash
 cycle/schema/php @runtime/schema.php
 ```
@@ -136,7 +135,7 @@ migrations based on them. For production use schema could be moved into a file.
 
 ### `PhpFileSchemaProvider` Provider
 
-Unlike `FromFilesSchemaProvider`, the `Cycle\Schema\Provider\PhpFileSchemaProvider` works with only one file. but, 
+Unlike `FromFilesSchemaProvider`, the `Cycle\Schema\Provider\PhpFileSchemaProvider` works with only one file. But,
 `PhpFileSchemaProvider` can not only read schema, but also save it.
 
 In the mode of reading and writing a schema file, the `PhpFileSchemaProvider` provider works similarly to the cache, with

docs/guide/pt-BR/README.md

@@ -0,0 +1,17 @@
+# Pacote Yii-Cycle
+
+Cycle é um mecanismo PHP DataMapper ORM e modelagem de dados projetado para funcionar com segurança em PHP clássico e
+aplicativos daemonizados como [RoadRunner](https://github.com/roadrunner-server/roadrunner).
+
+Leia mais na [documentação oficial do Cycle](https://cycle-orm.dev/docs/readme/2.x).
+
+Este pacote fornece uma maneira conveniente de integrá-lo ao framework Yii.
+
+- [Instalação e configuração](installation.md)
+- [Comandos do console](console-commands.md)
+- [Leitura do esquema do banco de dados](reading-schema.md)
+
+# Outros pacotes
+
+Há também um pacote adicional que forneceum  adaptador de consulta Cycle ORM para [Yii Data](https://github.com/yiisoft/data)
+chamado [Yii Data Cycle](https://github.com/yiisoft/data-cycle). Você pode usá-lo de forma independente ou em combinação com este pacote.

docs/guide/pt-BR/console-commands.md

@@ -0,0 +1,15 @@
+# Comandos do console
+
+## Comum
+
+- `cycle/schema` - Lista informações sobre o esquema usado
+- `cycle/schema/php [arquivo]` - Exporta o esquema atual como arquivo PHP
+- `cycle/schema/clear` - Limpa o cache do esquema atual
+
+## Migrações
+
+- `migrate/list` - Mostra a lista de migrações
+- `migrate/create <name>` - Crie o arquivo `<name>` de migração vazia
+- `migrate/generate` - Gera arquivo de migração com base na diferença entre o esquema baseado em notação de entidade e a estrutura do banco de dados
+- `migrate/up` - Aplicar todas as migrações ainda não aplicadas
+- `migrate/down` - Reverter a última migração

docs/guide/pt-BR/installation.md

@@ -0,0 +1,80 @@
+# Instalação
+
+A forma preferida de instalar este pacote é através do [Composer](https://getcomposer.org/download/):
+
+```bash
+compositor requer yiisoft/yii-cycle
+```
+
+## Configurando o pacote
+
+Se você usa Yii com `composer-config-plugin`, as configurações do Yii-Cycle podem ser especificadas em `config/params.php`:
+
+```php
+use Cycle\Schema\Generator;
+use Cycle\Schema\Provider\FromFilesSchemaProvider;
+use Cycle\Schema\Provider\SimpleCacheSchemaProvider;
+use Yiisoft\Yii\Cycle\Schema\Provider\FromConveyorSchemaProvider;
+
+return [
+    // Common Cycle config
+    'yiisoft/yii-cycle' => [
+        // Cycle DBAL config
+        'dbal' => [
+             // PSR-3 compatible SQL query logger
+            'query-logger' => null,
+            // Default database (from 'databases' list)
+            'default' => 'default',
+            'aliases' => [],
+            'databases' => [
+                'default' => ['connection' => 'sqlite']
+            ],
+            'connections' => [
+                // Example SQLite connection:
+                'sqlite' => new \Cycle\Database\Config\SQLiteDriverConfig(
+                    connection: new \Cycle\Database\Config\SQLite\DsnConnectionConfig(
+                        // see https://www.php.net/manual/pdo.construct.php, DSN for connection syntax
+                        dsn: 'sqlite:runtime/database.db'
+                    )
+                ),
+            ],
+        ],
+
+        // Migrations config
+        'migrations' => [
+            'directory' => '@root/migrations',
+            'namespace' => 'App\\Migration',
+            'table' => 'migration',
+            'safe' => false,
+        ],
+
+        /**
+         * A list of DB schema providers for {@see \Yiisoft\Yii\Cycle\Schema\Provider\Support\SchemaProviderPipeline}
+         * Providers are implementing {@see SchemaProviderInterface}.
+         * The configuration is an array of provider class names. Alternatively, you can specify provider class as key
+         * and its config as value:
+         */
+        'schema-providers' => [
+            SimpleCacheSchemaProvider::class => SimpleCacheSchemaProvider::config(
+                key: 'my-custom-cache-key'
+            ),
+            FromFilesSchemaProvider::class => FromFilesSchemaProvider::config(
+                files: ['@runtime/cycle-schema.php'],
+            ),
+            FromConveyorSchemaProvider::class,
+        ],
+
+        /**
+         * Option for {@see \Yiisoft\Yii\Cycle\Schema\Provider\FromConveyorSchemaProvider}.
+         * A list of entity directories. You can use {@see \Yiisoft\Aliases\Aliases} in paths.
+         */
+        'entity-paths' => [
+            '@src/Entity'
+        ],
+    ],
+];
+```
+
+Leia mais na documentação do Cycle:
+
+- [Conectar ao banco de dados](https://cycle-orm.dev/docs/database-configuration/2.x/en#installation-declare-connection)

docs/guide/pt-BR/reading-schema.md

@@ -0,0 +1,142 @@
+# Lendo o esquema do banco de dados
+
+O Cycle ORM depende do esquema do banco de dados - objeto, que implementa a interface `\Cycle\ORM\SchemaInterface`.
+
+Como um esquema é construído a partir de um array de uma determinada estrutura, podemos armazená-lo em cache ou em um arquivo de texto.
+
+Você pode exibir o esquema usado atualmente executando o comando `cycle/schema`.
+
+No `yii-cycle` o esquema do pacote pode ser construído a partir de múltiplas fontes representadas por múltiplos provedores implementando
+`Cycle\Schema\Provider\SchemaProviderInterface`.
+
+Para usar vários provedores de esquema por sua vez, provedor `Cycle\Schema\Provider\Support\SchemaProviderPipeline`
+é usado para agrupar. Você pode configurar este provedor na seção `schema-providers` de um arquivo `config/params.php`.
+Organize os provedores de esquema em tal ordem que os provedores de cache fiquem no topo da lista,
+e provedores de esquema de origem no final.
+
+## Esquema baseado em atributos de entidade
+
+Por padrão, o esquema é criado com base nos atributos que estão nas entidades do seu projeto.
+
+Ao construir um esquema, os geradores são executados sequencialmente. A sequência é determinada em uma instância de
+`SchemaConveyorInterface`. Você pode inserir seus próprios geradores neste transportador definindo-os na
+opção `entity-paths` do arquivo `config/params.php`.
+
+Para obter um esquema do transportador `FromConveyorSchemaProvider` é usado.
+
+O processo de construção de esquema a partir de atributos é relativamente pesado em termos de desempenho. Portanto, no caso de
+usar atributos, é uma boa ideia usar o cache de esquema.
+
+## Cache de esquema
+
+A leitura e gravação de um esquema de e para o cache acontece em `Cycle\Schema\Provider\SimpleCacheSchemaProvider`.
+
+Coloque-o no início da lista de provedores para tornar o processo de obtenção de um esquema significativamente mais rápido.
+
+## Esquema baseado em arquivo
+
+Se quiser evitar atributos, você pode descrever um esquema em um arquivo PHP.
+Use `Cycle\Schema\Provider\FromFilesSchemaProvider` para carregar um esquema:
+
+```php
+# config/common.php
+use Cycle\Schema\Provider\FromFilesSchemaProvider;
+
+return [
+    // ...
+    'yiisoft/yii-cycle' => [
+        // ...
+        'schema-providers' => [
+            FromFilesSchemaProvider::class => FromFilesSchemaProvider::config(fiels: ['@runtime/schema.php']),
+        ],
+    ]
+];
+```
+
+```php
+# runtime/schema.php
+use Cycle\ORM\Schema;
+return [
+   'user' => [
+        Schema::MAPPER      => \Cycle\ORM\Mapper\Mapper::class,
+        Schema::ENTITY      => \App\Entity\User::class,
+        Schema::DATABASE    => 'default',
+        Schema::TABLE       => 'users',
+        Schema::PRIMARY_KEY => 'id',
+        Schema::COLUMNS     => [
+           'id'   => 'id',
+           'name' => 'name'
+        ],
+        Schema::TYPECAST    => [
+           'id' => 'int'
+        ],
+        Schema::RELATIONS   => []
+    ]
+];
+```
+
+Observe que:
+
+1. `FromFilesSchemaProvider` carrega um esquema de arquivos PHP via `include`. Isso requer precauções de segurança.
+    Certifique-se de armazenar o arquivo de esquema em um caminho seguro e restrito aos usuários.
+2. Você pode especificar vários arquivos de esquema, que serão mesclados em um esquema.
+Uma exceção será lançada em caso de colisão de funções.
+
+3. Graças ao cache interno, carregar o esquema de um arquivo PHP é tão rápido que você pode pular um cache externo.
+Mas no caso de carregar vários arquivos, pode levar mais tempo para mesclá-los.
+4. Você não pode gerar migrações com base no esquema de arquivo PHP. [Veja a edição #25](https://github.com/yiisoft/yii-cycle/issues/25)
+5. O provedor apenas lê o esquema. Ele não pode atualizar o arquivo após a migração ser aplicada, como faz `SimpleCacheSchemaProvider`.
+
+## Construindo esquema de banco de dados de diferentes provedores
+
+Para mesclar partes do esquema obtidas de diferentes provedores, use `Cycle\Schema\Provider\MergeSchemaProvider`.
+
+```php
+# runtime/schema.php
+return [
+    // ...
+    'yiisoft/yii-cycle' => [
+        // ...
+        'schema-providers' => [
+            \Cycle\Schema\Provider\MergeSchemaProvider::class => [
+                // You can specify the provider class as the key and the configuration as the value.
+                // To generate a configuration array, you can use the static method `config()` of the
+                // provider class. In this case, autocomplete will be available.
+                \Cycle\Schema\Provider\FromFilesSchemaProvider::class => ['files' => ['@src/schema.php']],
+                // If you need to use multiple identically named schema providers,
+                // the provider and its configuration can be passed as an array of two elements.
+                [\Cycle\Schema\Provider\SimpleCacheSchemaProvider::class, ['key' => 'cycle-schema']],
+                // When defining the dependency as a string, make sure the container provides
+                // the already configured provider.
+                \Yiisoft\Yii\Cycle\Schema\Provider\FromConveyorSchemaProvider::class,
+            ]
+        ],
+    ]
+];
+```
+
+## Mudando de atributos para arquivo
+
+### Comando do console
+
+Para exportar o esquema como arquivo PHP, o comando `cycle/schema/php` pode ser usado.
+Especifique um nome de arquivo como argumento e o esquema será gravado nele:
+
+```bash
+cycle/schema/php @runtime/schema.php
+```
+
+O alias `@runtime` é substituído automaticamente. O esquema será exportado para o arquivo `schema.php`.
+
+Certifique-se de que o esquema exportado esteja correto e passe a usá-lo por meio de `FromFilesSchemaProvider`.
+
+Você pode combinar as duas maneiras para descrever um esquema. Durante o desenvolvimento do projeto é útil usar anotações. Você pode gerar
+migrações baseadas neles. Para uso em produção, o esquema pode ser movido para um arquivo.
+
+### Provedor `PhpFileSchemaProvider`
+
+Ao contrário de `FromFilesSchemaProvider`, o `Cycle\Schema\Provider\PhpFileSchemaProvider` funciona com apenas um arquivo. Mas,
+`PhpFileSchemaProvider` pode não apenas ler o esquema, mas também salvá-lo.
+
+No modo de leitura e gravação de um arquivo de esquema, o provedor `PhpFileSchemaProvider` funciona de forma semelhante ao cache, com
+a única diferença é que o resultado salvo (arquivo de esquema) pode ser salvo na base de código.