Updates pt-BR translation (#17105) [skip ci]

docs/guide-pt-BR/README.md

@@ -21,7 +21,7 @@ Primeiros Passos
 * [O que você precisa saber](start-prerequisites.md)
 * [Instalando o Yii](start-installation.md)
 * [Executando Aplicações](start-workflow.md)
-* [Fazendo um Hello-World](start-hello.md)
+* [Dizendo "Olá!"](start-hello.md)
 * [Trabalhando com Formulários](start-forms.md)
 * [Trabalhando com Bancos de Dados](start-databases.md)
 * [Gerando Código com Gii](start-gii.md)

docs/guide-pt-BR/start-databases.md

@@ -1,102 +1,101 @@
 Trabalhando com Bancos de Dados
 ===============================
 
-Esta seção descreverá como criar uma nova página que exibe dados de países
+Esta seção descreverá como criar uma nova página que exibe informações de países obtidos de uma tabela de banco de dados chamada `pais`. Para isso, você
-buscados de uma tabela do banco de dados chamada `country`. Para isso, você
 configurará uma conexão com o banco de dados, criará uma classe de
-[Active Record](db-active-record.md), definirá uma [action](structure-controllers.md) (ação),
+[Active Record](db-active-record.md), definirá uma [action](structure-controllers.md) e criará uma [view](structure-views.md).
-e criará uma [view](structure-views.md) (visão).
 
-Através deste tutorial, você aprenderá como:
+Ao longo deste tutorial, você aprenderá como:
 
-* Configurar uma conexão de BD
+* configurar uma conexão de BD
-* Definir uma classe de Active Record
+* definir uma classe Active Record
-* Consultar dados usando a classe de Active Record
+* consultar dados usando a classe de Active Record
-* Exibir dados em uma view de forma paginada
+* exibir dados em uma view de forma paginada
 
 Perceba que para terminar essa seção, você deve ter conhecimento e experiência
-básica usando bancos de dados. Em particular, você deveria saber como criar um
+básicos em bancos de dados. Em particular, você deve saber como criar um banco de dados e como executar instruções SQL usando uma ferramenta cliente de bancos de dados.
-banco de dados, e como executar instruções SQL usando uma ferramenta de cliente
-de BD.
 
 
 Preparando o Banco de Dados <span id="preparing-database"></span>
 ---------------------------
 
-Para começar, crie um banco de dados chamado `yii2basic`, a partir do qual você
+Para começar, crie um banco de dados chamado `yii2basico`, de onde você
-buscará os dados em sua aplicação. Você pode criar um banco de dados SQLite, MySQL,
+obterá os dados em sua aplicação. Você pode criar um banco de dados SQLite, MySQL,
-PostgreSQL, MSSQL ou Oracle, já que o Yii tem suporte embutido a muitas aplicações
+PostgreSQL, MSSQL ou Oracle, já que o Yii tem suporte embutido a vários gerenciadores de bancos de dados. Por questões de simplicidade, será assumido o uso do MySQL
-de bancos de dados. Por questões de simplicidade, será assumido o uso do MySQL
 na descrição a seguir.
 
-Em seguida, crie uma tabela chamada `country` no banco de dados, e insira alguns
+> Info: O MariaDB costumava ser um substituto transparente do MySQL. Isto já não é mais totalmente verdade. Caso você queira usar recursos avançados como suporte a `JSON` no MariaDB, por favor, consulte a extensão do MariaDB listada mais à frente.
-dados de exemplo. Você pode rodar as seguintes declarações SQL para fazê-lo:
+
+Em seguida, crie uma tabela chamada `pais` no banco de dados e insira alguns
+dados de exemplo. Você pode rodar as seguintes declarações SQL para fazer isso:
 
 ```sql
-CREATE TABLE `country` (
+CREATE TABLE `pais` (
-  `code` CHAR(2) NOT NULL PRIMARY KEY,
+  `codigo` CHAR(2) NOT NULL PRIMARY KEY,
-  `name` CHAR(52) NOT NULL,
+  `nome` CHAR(52) NOT NULL,
-  `population` INT(11) NOT NULL DEFAULT '0'
+  `populacao` INT(11) NOT NULL DEFAULT '0'
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-INSERT INTO `country` VALUES ('AU','Australia',24016400);
+INSERT INTO `pais` VALUES ('AU','Austrália',24016400);
-INSERT INTO `country` VALUES ('BR','Brazil',205722000);
+INSERT INTO `pais` VALUES ('BR','Brasil',205722000);
-INSERT INTO `country` VALUES ('CA','Canada',35985751);
+INSERT INTO `pais` VALUES ('CA','Canadá',35985751);
-INSERT INTO `country` VALUES ('CN','China',1375210000);
+INSERT INTO `pais` VALUES ('CN','China',1375210000);
-INSERT INTO `country` VALUES ('DE','Germany',81459000);
+INSERT INTO `pais` VALUES ('DE','Alemanha',81459000);
-INSERT INTO `country` VALUES ('FR','France',64513242);
+INSERT INTO `pais` VALUES ('FR','França',64513242);
-INSERT INTO `country` VALUES ('GB','United Kingdom',65097000);
+INSERT INTO `pais` VALUES ('GB','Reino Unido',65097000);
-INSERT INTO `country` VALUES ('IN','India',1285400000);
+INSERT INTO `pais` VALUES ('IN','Índia',1285400000);
-INSERT INTO `country` VALUES ('RU','Russia',146519759);
+INSERT INTO `pais` VALUES ('RU','Rússia',146519759);
-INSERT INTO `country` VALUES ('US','United States',322976000);
+INSERT INTO `pais` VALUES ('US','Estados Unidos',322976000);
 ```
 
-Neste ponto, você tem um banco de dados chamado `yii2basic`, e dentro dele uma
+Neste ponto, você tem um banco de dados chamado `yii2basico` e dentro dele uma
-tabela `country` com três colunas, contendo dez linhas de dados.
+tabela `pais` com três colunas, contendo dez linhas de dados.
 
-Configurando uma Conexão do BD <span id="configuring-db-connection"></span>
+Configurando uma Conexão de BD <span id="configuring-db-connection"></span>
 ------------------------------
 
 Antes de prosseguir, certifique-se de que você possui instalados tanto a
 extensão [PDO](http://www.php.net/manual/en/book.pdo.php) do PHP quanto o driver
-do PDO para a base que você está usando (por exemplo, `pdo_mysql` para o MySQL).
+PDO para o gerenciador de banco de dados que você está usando (por exemplo, `pdo_mysql` para o MySQL).
 Este é um requisito básico se a sua aplicação usa um banco de dados relacional.
 
-Tendo estes instalados, abra o arquivo `config/db.php` e mude os parâmetros para
+Tendo esses instalados, abra o arquivo `config/db.php` e mude os parâmetros conforme seu banco de dados.
-que estejam corretos para o seu banco de dados. Por padrão, o arquivo contém
+Por padrão, o arquivo contém o seguinte:
-o seguinte:
 
 ```php
 <?php
 
 return [
     'class' => 'yii\db\Connection',
-    'dsn' => 'mysql:host=localhost;dbname=yii2basic',
+    'dsn' => 'mysql:host=localhost;dbname=yii2basico',
     'username' => 'root',
     'password' => '',
     'charset' => 'utf8',
 ];
 ```
 
-O arquivo `config/db.php` é uma ferramenta de [configuração](concept-configurations.md)
+O arquivo `config/db.php` é uma típica ferramenta de [configuração](concept-configurations.md) baseada em arquivo. Este arquivo de configuração em particular especifica
-típica baseada em arquivos. Este arquivo de configuração em particular especifica
+os parâmetros necessários para criar e inicializar uma instância [[yii\db\Connection]]
-os parâmetros necessários para criar e inicializar uma instância de [[yii\db\Connection]]
+por meio da qual você pode fazer consultas SQL ao banco de dados subjacente.
-através da qual você pode fazer consultas de SQL ao banco de dados subjacente.
 
-A conexão de BD configurada acima pode ser acessada no código da aplicação
+A conexão configurada acima pode ser acessada no código da aplicação através da expressão `Yii::$app->db`.
-através da expressão `Yii::$app->db`.
 
-> Informação: O arquivo `config/db.php` será incluso pela configuração principal da
+> Info: O arquivo `config/db.php` será absorvido (incluso) pela configuração principal da
   aplicação `config/web.php`, que especifica como a instância da [aplicação](structure-applications.md)
-  deverá ser inicializada. Para mais informações, por favor consulte a seção sobre [Configurações](concept-configurations.md).
+  deve ser inicializada. Para mais informações, por favor, consulte a seção [Configurações](concept-configurations.md).
 
+Se você precisa trabalhar com bancos de dados para os quais não há suporte nativo no Yii, consulte as seguintes extensões:
+
+- [Informix](https://github.com/edgardmessias/yii2-informix)
+- [IBM DB2](https://github.com/edgardmessias/yii2-ibm-db2)
+- [Firebird](https://github.com/edgardmessias/yii2-firebird)
+- [MariaDB](https://github.com/sam-it/yii2-mariadb)
 
 Criando um Active Record <span id="creating-active-record"></span>
 ------------------------
 
-Para representar e buscar os dados da tabela `country`, crie uma classe que
+Para representar e buscar os dados da tabela `pais`, crie uma classe que deriva de [Active Record](db-active-record.md) chamada `Pais` e salve-a
-deriva de [Active Record](db-active-record.md) chamada `Country`, e salve-a
+no arquivo `models/Pais.php`.
-no arquivo `models/Country.php`.
 
 ```php
 <?php
@@ -105,55 +104,55 @@ namespace app\models;
 
 use yii\db\ActiveRecord;
 
-class Country extends ActiveRecord
+class Pais extends ActiveRecord
 {
 }
 ```
 
-A classe `Country` estende de [[yii\db\ActiveRecord]]. Você não precisa escrever
+A classe `Pais` estende de [[yii\db\ActiveRecord]]. Você não precisa escrever
-nenhum código nela! Só com o código acima, o Yii adivinhará o nome da tabela
+nenhum código nela! Só com o código acima, o Yii descobrirá o nome da tabela
 associada a partir do nome da classe.
 
-> Informação: Se não houver nenhuma correspondência direta do nome da classe com o nome
+> Info: Se não houver nenhuma correspondência direta do nome da classe com o nome
   da tabela, você pode sobrescrever o método [[yii\db\ActiveRecord::tableName()]]
   para especificar explicitamente o nome da tabela associada.
 
-Usando a classe `Country`, você pode manipular facilmente os dados na tabela
+Usando a classe `Pais`, você pode manipular facilmente os dados na tabela
-`country`, conforme é demonstrado nestes fragmentos:
+`pais`, conforme é demonstrado nos fragmentos de código a seguir:
 
 ```php
-use app\models\Country;
+use app\models\Pais;
 
-// obtém todas as linhas da tabela country e as ordena pela coluna "name"
+// obtém todas as linhas da tabela pais e as ordena pela coluna "nome"
-$countries = Country::find()->orderBy('name')->all();
+$paises = Pais::find()->orderBy('nome')->all();
 
-// obtém a linha cuja chave primária é "US"
+// obtém a linha cuja chave primária é "BR"
-$country = Country::findOne('US');
+$pais = Pais::findOne('BR');
 
-// exibe "United States"
+// exibe "Brasil"
-echo $country->name;
+echo $pais->nome;
 
-// altera o nome do país para ser "U.S.A." e o salva no banco de dados
+// altera o nome do país para "Brazil" e o salva no banco de dados
-$country->name = 'U.S.A.';
+$pais->nome = 'Brazil';
-$country->save();
+$pais->save();
 ```
 
-> Informação: O Active Record é uma maneira poderosa de acessar e manipular os dados
+> Info: O Active Record é uma maneira poderosa de acessar e manipular dados
-  do banco de dados de uma forma orientada a objeto. Você pode encontrar informações
+  do banco de dados de uma forma orientada a objetos. Você pode encontrar informações
-  mais detalhadas na seção [Active Record](db-active-record.md). Alternativamente,
+  mais detalhadas na seção [Active Record](db-active-record.md. Alternativamente,
-  você também pode interagir com o banco de dados usando um método de acesso aos
+  você também pode interagir com o banco de dados usando um método de acesso a
-  dados de baixo nível chamado [Data Access Objects](db-dao.md).
+  dados em baixo nível chamado [Objeto de Acesso a Dados (Data Access Objects)](db-dao.md).
 
 
 Criando uma Action <span id="creating-action"></span>
 ------------------
 
-Para expor os dados de países aos usuários finais, você precisaria de uma nova
+Para disponibiliar os dados de países aos usuários finais, você precisa criar uma nova
-action. Ao invés de colocar a nova action no controller (controlador) `site`,
+action. Em vez de colocar a nova action no controller `site`
 como você fez nas seções anteriores, faz mais sentido criar um novo controller
 especificamente para todas as actions relacionadas aos dados de países. Chame
-este novo controller de `CountryController`, e crie uma action `index` nele,
+este novo controller de `PaisController`, e crie uma action `index` nele,
-conforme o exemplo a seguir.
+conforme o exemplo a seguir:
 
 ```php
 <?php
@@ -162,55 +161,53 @@ namespace app\controllers;
 
 use yii\web\Controller;
 use yii\data\Pagination;
-use app\models\Country;
+use app\models\Pais;
 
-class CountryController extends Controller
+class PaisController extends Controller
 {
     public function actionIndex()
     {
-        $query = Country::find();
+        $query = Pais::find();
 
-        $pagination = new Pagination([
+        $paginacao = new Pagination([
             'defaultPageSize' => 5,
             'totalCount' => $query->count(),
         ]);
 
-        $countries = $query->orderBy('name')
+        $paises = $query->orderBy('nome')
-            ->offset($pagination->offset)
+            ->offset($paginacao->offset)
-            ->limit($pagination->limit)
+            ->limit($paginacao->limit)
             ->all();
 
         return $this->render('index', [
-            'countries' => $countries,
+            'paises' => $paises,
-            'pagination' => $pagination,
+            'paginacao' => $paginacao,
         ]);
     }
 }
 ```
 
-Salve o código acima em um arquivo `controllers/CountryController.php`.
+Salve o código acima no arquivo `controllers/PaisController.php`.
 
-A action `index` chama `Country::find()`. Este método do Active Record constrói
+A action `index` chama `Pais::find()`. Este método do Active Record constrói
-uma consulta do BD e retorna todos os dados da tabela `country`. Para limitar o
+uma consulta ao BD e retorna todos os dados da tabela `pais`. Para limitar o
-número de países retornados em cada requisição, a consulta é paginada com a ajuda
+número de países retornados a cada requisição, a consulta é paginada com a ajuda
 de um objeto [[yii\data\Pagination]]. O objeto `Pagination` serve para dois propósitos:
 
-* Definir as cláusulas `offset` e `limit` da declaração SQL representada pela
+* Define as cláusulas `offset` e `limit` da declaração SQL representada pela query
-  consulta de modo que apenas retorne uma única página de dados por vez (no máximo
+  (consulta) de modo que apenas retorne uma única página de dados por vez (no exemplo, no máximo
   5 linhas por página).
-* É usado para que a view exiba um paginador que consite de uma lista de botões
+* É usado na view para exibir um paginador que consiste de uma lista de botões de páginas, conforme será explicado na próxima subseção.
-  para as páginas, conforme será explicado na próxima sub-seção.
 
-No final do código, a action `index` renderiza uma view chamada `index`, e passa
+No final do código, a action `index` renderiza uma view chamada `index` e envia a ela os dados dos países e as informações de paginação.
-para ela os dados dos países bem como as informações de paginação.
 
 
 Criando uma View <span id="creating-view"></span>
 ----------------
 
-Dentro do diretório `views`, primeiro crie um sub-diretório chamado `country`.
+Dentro do diretório `views`, primeiro crie um subdiretório chamado `pais`.
 Esta pasta será usada para guardar todas as views renderizadas pelo controller
-`country`. Dentro do diretório `views/country`, crie um arquivo `index.php`
+`PaisController`. Dentro do diretório `views/pais`, crie um arquivo `index.php`
 contendo o seguinte:
 
 ```php
@@ -218,50 +215,48 @@ contendo o seguinte:
 use yii\helpers\Html;
 use yii\widgets\LinkPager;
 ?>
-<h1>Countries</h1>
+<h1>Países</h1>
 <ul>
-<?php foreach ($countries as $country): ?>
+<?php foreach ($paises as $pais): ?>
     <li>
-        <?= Html::encode("{$country->name} ({$country->code})") ?>:
+        <?= Html::encode("{$pais->nome} ({$pais->codigo})") ?>:
-        <?= $country->population ?>
+        <?= $pais->populacao ?>
     </li>
 <?php endforeach; ?>
 </ul>
 
-<?= LinkPager::widget(['pagination' => $pagination]) ?>
+<?= LinkPager::widget(['pagination' => $paginacao]) ?>
 ```
 
 A view tem duas seções relativas à exibição dos dados dos países. Na primeira parte,
-os dados de países fornecidos são cruzados e renderizados como uma lista do HTML.
+os dados de países fornecidos são percorridos e renderizados como uma lista HTML.
 Na segunda parte, um widget [[yii\widgets\LinkPager]] é renderizado usando as
 informações de paginação passadas pela action. O widget `LinkPager` exibe uma
-lista de botões para as páginas. Ao clicar em qualquer um deles atualizará
+lista de botões de páginas. Clicar em qualquer um deles vai atualizar os dados dos países conforme a página correspondente.
-os dados dos países com a página correspondente.
 
 
-Testando <span id="trying-it-out"></span>
+Conferindo <span id="trying-it-out"></span>
 --------
 
-Para verificar se todo os códigos acima funcionam, use o seu navegador para
+Para ver se todo os códigos acima funcionam, use o seu navegador para acessar a seguinte URL:
-acessar a seguinte URL:
 
 ```
-http://hostname/index.php?r=country/index
+http://hostname/index.php?r=pais/index
 ```
 
 ![Lista de Países](images/start-country-list.png)
 
 Primeiramente, você verá uma lista exibindo cinco países. Abaixo dos países,
 você verá um paginador com quatro botões. Se você clicar no botão "2", você
-verá a página exibindo outros cinco países no banco de dados: a segunda
+verá a página exibir outros cinco países do banco de dados: a segunda
 página de registros. Observe mais cuidadosamente e você perceberá que a URL no
 browser mudou para
 
 ```
-http://hostname/index.php?r=country/index&page=2
+http://hostname/index.php?r=pais/index&page=2
 ```
 
-Por baixo dos panos, [[yii\data\Pagination|Pagination]] está fornecendo toda
+Por trás das cortinas, [[yii\data\Pagination|Pagination]] está fornecendo toda
 a funcionalidade necessária para paginar um conjunto de dados:
 
 * Inicialmente, [[yii\data\Pagination|Pagination]] representa a primeira página,
@@ -271,8 +266,8 @@ a funcionalidade necessária para paginar um conjunto de dados:
   usando as URLs criadas pelo [[yii\data\Pagination::createUrl()|Pagination]].
   As URLs conterão um parâmetro `page`, que representa os diferentes números de
   páginas.
-* Se você clicar no botão da página "2", uma nova requisição para a rota
+* Se você clicar no botão de página "2", uma nova requisição para a rota
-  `country/index` será disparada e tratada. [[yii\data\Pagination|Pagination]] lê
+  `pais/index` será disparada e tratada. [[yii\data\Pagination|Pagination]] lê
   o parâmetro `page` da URL e define o número da página atual como sendo 2. A nova
   consulta de países então terá a cláusula `LIMIT 5 OFFSET 5` e retornará os
   próximos cinco países para a exibição.
@@ -285,9 +280,9 @@ Nesta seção, você aprendeu como trabalhar com um banco de dados. Você també
 aprendeu como buscar e exibir dados em páginas com a ajuda do
 [[yii\data\Pagination]] e do [[yii\widgets\LinkPager]].
 
-Na próxima seção, você aprenderá como usar a poderosa ferramenta geradora de códigos,
+Na próxima seção, você aprenderá como usar a poderosa ferramenta de geração de códigos,
 chamada [Gii](tool-gii.md), para ajudá-lo a implementar rapidamente algumas
 funcionalidades comumente necessárias, tais como as operações CRUD
-(Criar-Ler-Atualizar-Excluir) para trabalhar com os dados em uma tabela do
+(Criar-Ler-Atualizar-Excluir) para trabalhar com os dados de uma tabela do
 banco de dados. Na verdade, todo o código que você acabou de escrever pode ser
 gerado automaticamente no Yii usando a ferramenta Gii.

docs/guide-pt-BR/start-forms.md

@@ -1,28 +1,26 @@
 Trabalhando com Formulários
 ===========================
 
-Nesta seção descreve como se cria uma nova página com um formulário para obter
+Esta seção descreve como criar uma nova página com um formulário para receber
-dados a partir dos usuários. A página exibirá uma formulário com um campo para 
+dados dos usuários. A página exibirá um formulário com um campo para o nome e outro para o e-mail. Depois de obter essas duas informações do usuário, a página exibirá os valores inseridos de volta para confirmação.
-o nome e uma para o e-mail. Depois de obter essas duas informações a partir do 
-usuário, a página exibirá os valores inseridos de volta para a confirmação.
 
-Para atingir este objetivo, além de criar uma [ação](structure-controllers.md) (action) e 
+Para alcançar esse objetivo, além de criar uma [action](structure-controllers.md) e
-duas [visões](structure-views.md) (view), você também criará uma [modelo](structure-models.md) (model).
+duas [views](structure-views.md), você também criará um [model](structure-models.md).
 
-Através deste tutorial, você aprenderá como:
+No decorrer deste tutorial, você aprenderá como:
 
-* Criar um [modelo](structure-models.md) (model) para representar os dados inseridos pelo usuário por meio de um formulário
+* criar um [model](structure-models.md) para representar os dados que o usuário insere por meio de um formulário
-* Declarar regras (rules) para validar os dados inseridos
+* declarar regras (rules) para validar os dados inseridos
-* Criar um formulário HTML em uma [visão](structure-views.md) (view)
+* criar um formulário HTML em uma [view](structure-views.md)
 
 
-Criando uma Modelo (Model) <span id="creating-model"></span>
+Criando um Model <span id="creating-model"></span>
 ----------------
 
-Os dados a serem solicitados pelo usuário será representados por uma classe modelo
+Os dados a serem solicitados do usuário serão representados por uma classe model
-`EntryForm` como mostro a seguir e salvos no arquivo `models/EntryForm.php`. Por 
+`FormularioDeRegistro`, como visto a seguir, que será salva no arquivo `models/FormularioDeRegistro.php`. Por
-favor consulte a seção [Autoloading de Classes](concept-autoloading.md) para mais 
+favor, consulte a seção [Autoloading de Classes](concept-autoloading.md) para mais
-detalhes sobre convenção de nomenclatura dos arquivos de classes.
+detalhes sobre convenção de nomenclatura de arquivos de classes.
 
 ```php
 <?php
@@ -32,62 +30,59 @@ namespace app\models;
 use Yii;
 use yii\base\Model;
 
-class EntryForm extends Model
+class FormularioDeRegistro extends Model
 {
-    public $name;
+    public $nome;
-    public $email;
+    public $e_mail;
 
     public function rules()
     {
         return [
-            [['name', 'email'], 'required'],
+            [['nome', 'e_mail'], 'required'],
-            ['email', 'email'],
+            [['e_mail'], 'email'],
         ];
     }
 }
 ```
 
-A classe estende de [[yii\base\Model]], uma classe base fornecida pelo Yii, 
+A classe estende de [[yii\base\Model]], uma classe base fornecida pelo Yii comumente usada para representar dados de formulários.
-comumente usados para representar dados do formulário.
 
-> Informação: O [[yii\base\Model]] é usado como pai das classes modelos que *não* 
+> Info: [[yii\base\Model]] é usado como pai das classes de models que *não*
-são associadas com tabelas do banco de dados.
+são associadas com tabelas de bancos de dados.
-O [[yii\db\ActiveRecord]] é normalmente usado como pai das classes modelos que 
+Enquanto [[yii\db\ActiveRecord]], como pai das classes de models que correspondem a tabelas de bancos de dados.
-correspondem a tabelas do banco de dados.
 
-A classe `EntryForm` contém dois atributos públicos, `name` e `email`, que são 
+A classe `FormularioDeRegistro` contém dois atributos públicos, `nome` e `e_mail`, que são
-usados para guardar os dados fornecidos pelo usuário. Ele também contém um método
+usados para armazenar os dados fornecidos pelo usuário. Ele também contém um método
 chamado `rules()`, que retorna um conjunto de regras para validação dos dados.
-As regras de validação declaradas no código acima permitem que:
+As regras de validação declaradas no código acima declaram que:
 
-* tanto os valores do `name` quanto do `email` sejam obrigatórios
+* tanto o `nome` quanto o `e_mail` são obrigatórios
-* os dados do `email` devem ser um e-mail válido sintaticamente
+* o `e_mail` deve ser preenchido com um e-mail sintaticamente válido (por exemplo, um valor sem @ não pode ser considerado válido para um e-mail, etc.)
 
-Se você tiver um objeto `EntryForm` populado com dados fornecidos pelo usuário,
+Se você tem um objeto `FormularioDeRegistro` preenchido com dados fornecidos pelo usuário,
-você pode chamar o [[yii\base\Model::validate()|validate()]] para iniciar as 
+você pode chamar seu método [[yii\base\Model::validate()|validate()]] para iniciar as rotinas de validação dos dados. Se a validação de dados falhar, a propriedade
-rotinas de validação dos dados. A validação dos dados falhar, a propriedade 
 [[yii\base\Model::hasErrors|hasErrors]] será definida como *true* e você pode
-saber quais erros ocorrerão pela validação através de [[yii\base\Model::getErrors|errors]].
+saber quais erros de validação ocorreram por consultar [[yii\base\Model::getErrors|errors]].
 
 ```php
 <?php
-$model = new EntryForm();
+$model = new FormularioDeRegistro();
-$model->name = 'Qiang';
+$model->nome = 'Fulano';
-$model->email = 'bad';
+$model->e_mail = 'emailruim';
 if ($model->validate()) {
     // Bom!
 } else {
-    // Falha!
+    // Falhou!
     // Utilize $model->getErrors()
 }
 ```
 
 
-Criando uma Ação <span id="creating-action"></span>
+Criando uma Action <span id="creating-action"></span>
 ------------------
 
-Em seguida, você precisará criar uma ação `entry` no controlador `site` que será usado no novo modelo. O processo de criação e utilização das ações são explicadas na seção 
+Em seguida, você precisará criar uma action `registro` no controller `site` que usará o novo model. O processo de criação e utilização de ações foi explicado na seção
-[Como Fazer um "Hello World"](start-hello.md).
+[Dizendo "Olá!"](start-hello.md).
 
 ```php
 <?php
@@ -96,77 +91,68 @@ namespace app\controllers;
 
 use Yii;
 use yii\web\Controller;
-use app\models\EntryForm;
+use app\models\FormularioDeRegistro;
 
 class SiteController extends Controller
 {
     // ...código existente...
 
-    public function actionEntry()
+    public function actionRegistro()
     {
-        $model = new EntryForm();
+        $model = new FormularioDeRegistro();
 
         if ($model->load(Yii::$app->request->post()) && $model->validate()) {
-            // dados válidos recebidos pelo $model
+            // dados válidos recebidos no $model
 
-            // fazer alguma coisa aqui sobre $model ...
+            // faça alguma coisa significativa com o $model aqui ...
 
-            return $this->render('entry-confirm', ['model' => $model]);
+            return $this->render('confirmar-registro', ['model' => $model]);
         } else {
-            // Ou a página é exibida inicialmente ou existe algum erro de validação
+            // Ou a página esta sendo exibida inicial ou houve algum erro de validação
-            return $this->render('entry', ['model' => $model]);
+            return $this->render('registro', ['model' => $model]);
         }
     }
 }
 ```
 
-A primeira ação cria um objeto `EntryForm`. Ele, então, tenta popular o modelo 
+A primeira action cria um objeto `FormularioDeRegistro`. Ele, então, tenta preencher o model com os dados de `$_POST`, fornecidos no Yii por [[yii\web\Request::post()]].
-(model) com os dados vindos do `$_POST`, fornecidos pelo [[yii\web\Request::post()]]
+Se o model for preenchido (observe o método `load()`) com sucesso, ou seja, se o usuário
-no Yii. Se o modelo (model) for populado com sucesso (por exemplo, se o usuário
+enviou o formulário HTML, a action chamará o [[yii\base\Model::validate()|validate()]]
-enviar o formulário HTML), a ação chamará o [[yii\base\Model::validate()|validate()]] 
+para se certificar de que os valores fornecidos são válidos.
-para certifique-se que os valores fornecidos são válidos.
 
-> Informação: A expressão `Yii::$app` representa a instância da 
+> Info: A expressão `Yii::$app` representa a instância da
-  [aplicação](structure-applications.md), que é globalmente acessível via singleton. 
+  [aplicação](structure-applications.md), que é um "singleton" globalmente acessível.
-  Também é um [service locator](concept-service-locator.md) que fornece componentes 
+  Ao mesmo tempo, é um [service locator](concept-service-locator.md) que fornece componentes
-  tais como `request`, `response`, `db`, etc. para suportar a funcionalidade específica.
+  tais como `request`, `response`, `db`, etc., para permitir funcionalidades específicas.
-  No código acima, o componente `request` da instância da aplicação é usada para
+  No código acima, o componente `request` da instância da aplicação é usado para acessar os dados do `$_POST`.
-  acessar os dados do `$_POST`.
 
-Se tudo tiver certo, a ação renderizará a visão chamada `entry-confirm` para 
+Se tudo estiver certo, a action renderizará a view chamada `confirmar-registro` para confirmar ao usuário que os dados foram enviados corretamente. Se nenhum dado foi enviado ou se tiverem erros, a view `registro` será renderizada novamente
-confirmar os dados enviados pelo usuário. Se ao enviar o formulário não 
+e seu formulário HTML voltará a ser exibido mas, dessa vez, juntamente com as mensagens de erro de validação.
-houver dados ou se os dados tiverem erros, a visão `entry` será renderizada, 
-em que o formulário será exibigo, juntamente com as mensagens de erros da 
-validação.
 
-> Nota: Neste exemplo muito simples, acabamos de renderizar um página de confirmação
+> Nota: Neste exemplo muito simples, renderizamos a página de confirmação somente se os dados enviados eram válidos. Na prática, você deve considerar usar [[yii\web\Controller::refresh()|refresh()]] ou [[yii\web\Controller::redirect()|redirect()]]
-  mediante a dados válidos enviados de uma formulário. Em prática, você poderia 
+  para evitar [problemas de reenvio de formulário](http://en.wikipedia.org/wiki/Post/Redirect/Get).
-  considerar usar [[yii\web\Controller::refresh()|refresh()]] ou [[yii\web\Controller::redirect()|redirect()]]
-  para evitar [problemas ao reenviar formulários](http://en.wikipedia.org/wiki/Post/Redirect/Get).
 
 
-Criando Visões <span id="creating-views"></span>
+Criando Views <span id="creating-views"></span>
 --------------
 
-Finalmente, crie dois arquivos de visões chamados de `entry-confirm` e `entry`. 
+Por fim, crie dois arquivos de views chamados `confirmar-registro` e `registro`. Essas serão as views renderizadas pela action `registro`, como acabamos de descrever acima.
-Estas visões serão renderizados pela ação `entry`, como descrito anteriormente.
 
-A visão `entry-confirm` simplesmente exibe os dados dos campos `name` e `email`. 
+A view `confirmar-registro` simplesmente exibe os dados dos campos `nome` e `e_mail` e deve ser salva no arquivo `views/site/confirmar-registro.php`.
-Deverá ser salvo no arquivo `views/site/entry-confirm.php`.
 
 ```php
 <?php
 use yii\helpers\Html;
 ?>
-<p>You have entered the following information:</p>
+<p>Você enviou as seguintes informações:</p>
 
 <ul>
-    <li><label>Name</label>: <?= Html::encode($model->name) ?></li>
+    <li><label>Nome</label>: <?= Html::encode($model->nome) ?></li>
-    <li><label>Email</label>: <?= Html::encode($model->email) ?></li>
+    <li><label>E-mail</label>: <?= Html::encode($model->e_mail) ?></li>
 </ul>
 ```
 
-A visão `entry` exibe um formulário HTML. Deverá ser salvo no arquivo `views/site/entry.php`.
+A view `registro` exibe um formulário HTML e deve ser salva no arquivo `views/site/registro.php`.
 
 ```php
 <?php
@@ -175,97 +161,86 @@ use yii\widgets\ActiveForm;
 ?>
 <?php $form = ActiveForm::begin(); ?>
 
-    <?= $form->field($model, 'name') ?>
+    <?= $form->field($model, 'nome') ?>
 
-    <?= $form->field($model, 'email') ?>
+    <?= $form->field($model, 'e_mail') ?>
 
     <div class="form-group">
-        <?= Html::submitButton('Submit', ['class' => 'btn btn-primary']) ?>
+        <?= Html::submitButton('Enviar', ['class' => 'btn btn-primary']) ?>
     </div>
 
 <?php ActiveForm::end(); ?>
 ```
 
-A visão usa o poderoso [widget](structure-widgets.md) chamado 
+A view usa um poderoso [widget](structure-widgets.md) chamado
-[[yii\widgets\ActiveForm|ActiveForm]] para criar o formulário HTML. Os métodos 
+[[yii\widgets\ActiveForm|ActiveForm]] para construir o formulário HTML. Os métodos
-`begin()` e `end()` do widget renderizam a abertura e o fechamento da tag do 
+`begin()` e `end()` do widget renderizam as tags de abertura e de fechamento do formulário.
-formulário. Entre os dois métodos chamados, os campos de entrada são criados pelo
+Entre as duas chamadas de métido, campos são criados pelo
-método [[yii\widgets\ActiveForm::field()|field()]]. O primeiro campo de entrada
+método [[yii\widgets\ActiveForm::field()|field()]]. O primeiro campo é para o nome e o segundo é para o e-mail. Após os campos,
-é para o "name" (nome) e o segundo é para o "email". Após os campos de entrada,
+o método [[yii\helpers\Html::submitButton()]] é chamado para criar um botão de envio do formulário (submit).
-o método [[yii\helpers\Html::submitButton()]] é chamado para criar o botão 
-de enviar.
 
 
-Testando <span id="trying-it-out"></span>
+Conferindo <span id="trying-it-out"></span>
 -------------
 
-Para ver como ele funciona, utilize seu navegador para acessar a seguinte URL:
+Para ver como funciona, utilize seu navegador para acessar a seguinte URL:
 
 ```
-http://hostname/index.php?r=site/entry
+http://hostname/index.php?r=site/registro
 ```
 
-Você verá uma página exibindo um formulário com dois campos de entrada. Na frente 
+Você verá uma página exibindo um formulário com dois campos. Na frente de cada campo, um *label* indica quais dados devem ser inseridos. Se você clicar
-de cada campo, um *label* indicando quais dados devem ser inseridos. Se você clicar
+no botão Enviar sem informar nenhum dado, ou se você não fornecer um e-mail
-no botão de enviar sem informar nenhum dado, ou se você não fornecer um e-mail 
+válido, você verá uma mensagem de erro próxima a cada campo com problema.
-válido, você verá uma mensagem de erro após cada campo de entrada.
 
-![Form with Validation Errors](images/start-form-validation.png)
+![Formulário com Erros de Validação](images/start-form-validation.png)
 
 Após informar um nome e e-mail válidos e clicar no botão de enviar, você verá uma
 nova página exibindo os dados informados por você.
 
-![Confirmation of Data Entry](images/start-entry-confirmation.png)
+![Confirmação de Registro](images/start-entry-confirmation.png)
 
 
 
-### Explicação da Mágica <span id="magic-explained"></span>
+### Mágica Explicada <span id="magic-explained"></span>
 
-Você pode querer saber como o formulário HTML trabalha por baixo dos panos, porque 
+Você talvez se pergunte como o formulário HTML trabalha por trás das cortinas, já que parece
-parece quase mágica exibir um *label* para cada campo de entrada e mostrar mensagens
+quase mágica exibir um *label* para cada campo e mostrar mensagens
-de erro quando você não informa dados corretos sem recarregar a página.
+de erro sem recarregar a página quando você não informa os dados corretamente.
 
-Sim, a validação dos dados inicialmente é feito no lado do cliente usando JavaScript
+Sim, a validação de dados inicialmente é feita no cliente usando JavaScript e, posteriormente, realizada no servidor via PHP.
-e posteriormente realizada no lado do servidor via PHP.
+O [[yii\widgets\ActiveForm]] é esperto o suficiente para extrair as regras de
-O [[yii\widgets\ActiveForm]] é inteligente o suficiente para extrair as regras de 
+validação que você declarou no `FormularioDeRegistro`, transformá-las em código JavaScript executável e usar esse
-validação declaradas no `EntryForm`, transformando-as em códigos JavaScript e utilizando 
+código JavaScript para realizar a validação de dados. Caso você tenha desabilitado o JavaScript em seu navegador, a validação ainda será realizada no servidor, como mostrado
-o JavaScript para realizar as validações dos dados. No caso do JavaScript estiver desabilitado
+no método `actionRegistro()`. Isso garante a validade dos dados em todas as circunstâncias.
-em seu navegador, a validação ainda será realizada pelo lado do servidor, como mostrado
-no método `actionEntry()`. Isso garante que os dados serão validados em qualquer 
-circunstância.
 
-> Aviso: A validação feita pelo lado do cliente é uma conveniência que fornece uma melhor
+> Warning: (Alerta!) A validação feita no cliente é uma conveniência que fornece uma melhor
-  experiência para o usuário. A validação feita pelo lado do servidor é sempre necessária
+  experiência para o usuário. A validação feita no servidor é sempre necessária, quer a validação no cliente aconteça, quer não.
-  com ou sem validação no lado do cliente.
 
-Os *labels* dos campos de entrada são geradas pelo método `field()`, usando os nomes 
+Os *labels* dos campos são gerados pelo método `field()`, usando os nomes
-das propriedades do modelo (model).
+das propriedades do model.
-Por exemplo, um *label* chamado `Name` será gerado para a propriedade `name`. 
+Por exemplo, um *label* chamado `Nome` será gerado para a propriedade `nome`.
 
-Você pode personalizar um *label* em uma visão utilizando o seguinte código:
+Você pode personalizar um *label* em uma view utilizando o seguinte código:
 
 ```php
-<?= $form->field($model, 'name')->label('Your Name') ?>
+<?= $form->field($model, 'nome')->label('Seu Nome') ?>
-<?= $form->field($model, 'email')->label('Your Email') ?>
+<?= $form->field($model, 'e_mail')->label('Seu E-mail') ?>
 ```
 
-> Informação: O Yii fornece muitos destes widgets para lhe ajudar a criar rapidamente
+> Info: O Yii fornece muitos desses widgets para ajudá-lo a construir rapidamente views dinâmicas e complexas.
-  complexas e dinâmicos layouts.
+  Conforme você vai aprender mais tarde, escrever um novo widget também é extremamente fácil.
-  Como você vai aprender mais tarde, escrever um novo widget é também extremamenet fácil.
+  Você talvez queira transformar grande parte do código de suas views em widgets reutilizáveis
-  Você pode querer transformar grande parte do seu código de visão em reutilizáveis 
+  para simplificar o desenvolvimento de views no futuro.
-  widget para simplificar o desenvolvimento de visões no futuro.
 
 
 Resumo <span id="summary"></span>
 -------
 
-Nesta seção, você tocou em cada parte do padrão de arquitetura MVC. 
+Nesta seção do guia, você teve uma introduçao à última parte do padrão de arquitetura MVC. Você aprendeu como criar uma classe model para representar os dados do usuário e validá-los.
-Aprendeu como criar uma classe modelo (model) para representar os dados do usuário 
-e validá-los.
 
 Também aprendeu como obter os dados enviados pelos usuários e como exibi-los de
-volta no navegador. Esta é uma tarefa que poderia levar muito tempo ao desenvolver
+volta no navegador. Essa é uma tarefa que poderia tomar muito tempo ao desenvolver uma aplicação, mas o Yii fornece widgets poderosos que tornam o processo muito simples.
-uma aplicação, mas o Yii fornece widgets inteligentes para gerar estas tarefas de 
+
-forma simples.
+Na próxima seção, você aprenderá como trabalhar com bancos de dados, que são
-Na próxima seção, você aprenderá como trabalhar com banco de dados, os quais são 
 necessários em quase todas as aplicações.

docs/guide-pt-BR/start-gii.md

@@ -1,20 +1,20 @@
 Gerando Código com Gii
 ========================
 
-Essa seção irá descrever como usar o [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) para  gerar automaticamente código que implementa algumas funcionalidades comuns de sites. Usar o Gii para gerar código é simples, trata-se apenas de uma questão de entrar com as informações corretas de acordo com as instruções mostradas nas páginas do Gii.
+Essa seção irá descrever como usar o [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) para  gerar automaticamente código que implementa algumas funcionalidades comuns de sites. Usar o Gii para gerar código é simplesmente uma questão de informar os dados corretos conforme as instruções mostradas nas páginas do Gii.
 
 Através desse tutorial, você irá aprender a:
 
-* Habilitar o Gii em sua aplicação
+* habilitar o Gii em sua aplicação,
-* Usar o Gii para gerar uma classe Active Record
+* usar o Gii para gerar uma classe Active Record,
-* Usar o Gii para gerar código que implementa as operações CRUD para uma tabela do BD
+* usar o Gii para gerar código que implementa as operações CRUD para uma tabela do banco de dados, e
-* Customizar o código gerado pelo Gii
+* personalizar o código gerado pelo Gii.
 
 
 Começando a usar o Gii <span id="starting-gii"></span>
 ------------
 
-O [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) é fornecido com o Yii como um [módulo](structure-modules.md). Você pode habilitar o Gii ao configurá-lo na propriedade [[yii\base\Application::modules|modules]] da aplicação. Dependendo de como você criou sua aplicação, você pode já encontrar o seguinte código no arquivo de configuração `config/web.php`:
+O [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) é fornecido como um [módulo](structure-modules.md) do Yii. Você pode habilitar o Gii ao configurá-lo na propriedade [[yii\base\Application::modules|modules]] da aplicação. Dependendo de como você criou sua aplicação, você pode encontrar o seguinte código já pronto no arquivo de configuração `config/web.php`:
 
 ```php
 $config = [ ... ];
@@ -27,22 +27,22 @@ if (YII_ENV_DEV) {
 }
 ```
 
-A configuração acima declara que quando se está em [ambiente de desenvolvimento](concept-configurations.md#environment-constants), a aplicação deve incluir um módulo chamado `gii`, da classe [[yii\gii\Module]].
+A configuração acima declara que, quando estiver usando o [ambiente de desenvolvimento](concept-configurations.md#environment-constants), a aplicação deve incluir um módulo chamado `gii`, da classe [[yii\gii\Module]].
 
-Se você checar o [script inicial](structure-entry-scripts.md) `web/index.php` da sua aplicação, você encontrará a seguinte linha, que essencialmente faz com que o `YII_ENV_DEV` seja verdadeiro.
+Se você verificar o [script de entrada](structure-entry-scripts.md) `web/index.php` da sua aplicação, você encontrará a seguinte linha que, basicamente, torna  `YII_ENV_DEV` verdadeira.
 
 ```php
 defined('YII_ENV') or define('YII_ENV', 'dev');
 ```
 
-Graças a essa linha, sua aplicação está em modo de desenvolvimento e estará com o Gii habilitado, pela configuração acima. Agora você pode acessar o Gii pela URL:
+Graças a essa linha, sua aplicação está em modo de desenvolvimento e terá o Gii habilitado, devido a configuração mais acima. Agora você pode acessar o Gii pela URL:
 
 ```
 http://hostname/index.php?r=gii
 ```
 
-> Observação: Se você está acessando o Gii por um endereço IP que não seja o localhost, o acesso será negado por padrão.
+> Note: Se você está acessando o Gii por um endereço IP que não seja o localhost, o acesso será negado por padrão, por questões de segurança.
-> Para mudar isso, adicione a lista de endereços IP permitidos à configuração:
+> Você pode configurar o Gii adicionando endereços IP permitidos como mostrado a seguir:
 >
 ```php
 'gii' => [
@@ -57,32 +57,32 @@ http://hostname/index.php?r=gii
 Gerando uma classe Active Record <span id="generating-ar"></span>
 ---------------------------------
 
-Para usar o Gii para gerar uma classe Active Record, selecione o "Model Generator" clicando no link na página inicial do Gii. Preencha o formulário como indicado abaixo:
+Para gerar uma classe Active Record usando o Gii, selecione o "Model Generator" clicando no link na página inicial do Gii. Então, preencha o formulário como indicado abaixo:
 
-* Nome da tabela: `country`
+* Nome da tabela: `pais`
-* Classe do modelo: `Country`
+* Classe do modelo: `Pais`
 
 ![Gerador de Modelo](images/start-gii-model.png)
 
-Em seguida, clique no botão "Preview". Você verá o `models/Country.php` listado como arquivo a ser criado. Você pode clicar no nome do arquivo para pré-visualizar seu conteúdo.
+Em seguida, clique no botão "Preview". Você verá o `models/Pais.php` listado como arquivo a ser criado. Você pode clicar no nome do arquivo para pré-visualizar seu conteúdo.
 
 Ao usar o Gii, se você já havia criado o mesmo arquivo e pretende sobrescrevê-lo, clique no botão `diff` próximo ao nome do arquivo para ver as diferenças entre o código a ser gerado e a versão já existente.
 
 ![Pré-visualização do Gerador de Modelo](images/start-gii-model-preview.png)
 
-Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "overwrite" (sobrescrever) e clique no botão "Generate". Se estiver criando um arquivo novo, apenas clique em "Generate".
+Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "overwrite" (sobrescrever) e clique no botão "Generate". Se estiver criando um novo arquivo, apenas clique em "Generate".
 
-Em seguida, você verá uma página de confirmação indicando que o código foi gerado com sucesso. Se você já tinha um arquivo, também verá uma mensagem indicando que ele foi sobrescrito com o novo código.
+Em seguida, você verá uma página de confirmação indicando que o código foi gerado com sucesso. Se você já tinha um arquivo, também verá uma mensagem indicando que ele foi sobrescrito pelo novo código.
 
 
 Gerando código CRUD <span id="generating-crud"></span>
 --------------------
 
-CRUD corresponde a Create, Read, Update, and Delete (criar, ler, atualizar e apagar), representando as quatro tarefas comuns feitas com os dados na maioria dos sites. Para criar funcionalidades CRUD usando o Gii, selecione "CRUD Generator" clicando no link na página inicial do Gii. Seguindo o exemplo "country", preencha o formulário com as seguintes informações:
+CRUD significa a Create, Read, Update, and Delete (criar, ler, atualizar e apagar), representando as quatro tarefas comuns feitas com os dados na maioria das aplicações. Para criar funcionalidades CRUD usando o Gii, selecione "CRUD Generator" clicando no link na página inicial do Gii. Seguindo o exemplo "pais", preencha o formulário com as seguintes informações:
 
-* Classe do Modelo: `app\models\Country`
+* Model Class: `app\models\Pais`
-* Classe da Busca: `app\models\CountrySearch`
+* Search Model Class: `app\models\PaisSearch`
-* Classe do Controller: `app\controllers\CountryController`
+* Controller Class: `app\controllers\PaisController`
 
 ![Gerador de CRUD](images/start-gii-crud.png)
 
@@ -90,38 +90,38 @@ Em seguida, clique no botão "Preview". Você verá uma lista de arquivos a sere
 
 ![Pré-visualização do Gerador de CRUD](images/start-gii-crud-preview.png)
 
-Se você criou anteriormente os arquivos `controllers/CountryController.php` e
+Se você criou anteriormente os arquivos `controllers/PaisController.php` e
-`views/country/index.php` (na seção de banco de dados deste guia), marque a caixa "overwrite" para substitui-los. (As versões anteriores não tinham suporte completo às operações CRUD.)
+`views/pais/index.php` (na seção de banco de dados deste guia), marque a caixa "overwrite" para substitui-los. (As versões anteriores não tinham suporte completo às operações CRUD.)
 
 
-Checando os resultados <span id="trying-it-out"></span>
+Conferindo <span id="trying-it-out"></span>
 -------------
 
 Para ver como ficou, use seu navegador para acessar a seguinte URL:
 
 ```
-http://hostname/index.php?r=country/index
+http://hostname/index.php?r=pais/index
 ```
 
 Você verá uma tabela mostrando os países do seu banco de dados. Você pode ordená-los ou filtrá-los inserindo condições nos cabeçalhos das colunas.
 
 Para cada país exibido na tabela, você pode visualizar detalhes, editar ou excluir.
-Você também pode clicar no botão “Create Country” no topo da tabela para ter acesso a um formulário de criação de um novo país.
+Você também pode clicar no botão “Create Pais” no topo da tabela para ter acesso a um formulário para cadastrar um novo país.
 
-![Tabela de Países](images/start-gii-country-grid.png)
+![Grade de Países](images/start-gii-country-grid.png)
 
 ![Editando um País](images/start-gii-country-update.png)
 
-Essa é uma lista de arquivos gerados pelo Gii, caso você queira investigar como essas funcionalidades são implementadas ou adaptá-las:
+Esta é uma lista de arquivos gerados pelo Gii, caso você queira investigar como essas funcionalidades estão implementadas ou ajustá-las:
 
-* Controller: `controllers/CountryController.php`
+* Controller: `controllers/PaisController.php`
-* Modelo: `models/Country.php` e `models/CountrySearch.php`
+* Modelo: `models/Pais.php` e `models/PaisSearch.php`
-* Views: `views/country/*.php`
+* Views: `views/pais/*.php`
 
-> Informação: o Gii é projetado para ser uma ferramenta altamente adaptável e extensível. Usando-o sabiamente, você irá acelerar o desenvolvimento da sua aplicação. Para mais detalhes, por favor siga para a seção [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md).
+> Info: o Gii é projetado para ser uma ferramenta altamente adaptável e extensível. Usando-o sabiamente, você pode acelerar bastante o desenvolvimento de sua aplicação. Para mais detalhes, por favor, consulte a seção [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md).
 
 
 Resumo <span id="summary"></span>
 -------
 
-Nessa seção, você aprendeu a usar o Gii para gerar código que implementa funcionalidades CRUD para o conteúdo guardado em uma tabela do banco de dados.
+Nessa seção, você aprendeu a usar o Gii para gerar código que implementa todas as operações CRUD para o conteúdo armazenado em uma tabela de banco de dados.

docs/guide-pt-BR/start-hello.md

@@ -1,38 +1,33 @@
-Como Fazer um "Hello World"
+Dizendo "Olá!"
 =====================
 
-Esta seção descreve como criar uma nova página de "Hello" em sua aplicação.
+Esta seção descreve como criar uma nova página de "Olá!" em sua aplicação.
-Para atingir este objetivo, você criará uma [ação](structure-controllers.md#creating-actions)
+Para atingir este objetivo, você criará uma [action](structure-controllers.md#creating-actions)
-(action) e uma [visão](structure-views.md) (view):
+e uma [view](structure-views.md):
 
-* A aplicação enviará a requisição de página para a ação
+* A aplicação enviará a requisição de página para a action
-* e a ação por sua vez renderizará a view que mostra as palavras "Hello"
+* e a action, por sua vez, renderizará a view que mostra a palavra "Olá!" ao usuário final.
-  para o usuário final.
 
 Através deste tutorial, você aprenderá três coisas:
 
-1. Como criar uma [ação](structure-controllers.md) para responder às requisições,
+1. Como criar uma [action](structure-controllers.md) para responder às requisições,
-2. como criar uma [visão](structure-views.md) para compor o conteúdo da resposta, e
+2. como criar uma [view](structure-views.md) para compor o conteúdo da resposta, e
-3. como uma aplicação envia as requisições para as [ações](structure-controllers.md#creating-actions).
+3. como uma aplicação envia requisições às [actions](structure-controllers.md#creating-actions).
 
 
-Criando uma Ação <span id="creating-action"></span>
+Criando uma Action <span id="creating-action"></span>
 ----------------
 
-Para a tarefa "Hello", você criará uma [ação](structure-controllers.md#creating-actions)
+Para a tarefa "Olá!", você criará uma [action](structure-controllers.md#creating-actions)
-`say` que lê um parâmetro `message` da requisição e exibe essa mensagem de volta
+`cumprimentar` que lê um parâmetro `mensagem` da requisição e exibe essa mensagem de volta
-para o usuário. Se a requisição não fornecer um parâmetro `message`, a ação
+para o usuário. Se a requisição não fornecer um parâmetro `mensagem`, a action exibirá a mensagem padrão "Olá!".
-exibirá a mensagem padrão "Hello".
 
-> Informação: [Ações](structure-controllers.md#creating-actions) são os objetos aos
+> Info: [Actions](structure-controllers.md#creating-actions) são os objetos que usuários finais podem solicitar diretamente para execução. Actions são
-  quais os usuários finais podem se referir diretamente para execução. As ações são
+  agrupadas nos [controllers](structure-controllers.md). O resultado da execução de uma action é a resposta que o usuário final receberá.
-  agrupadas nos [controladores](structure-controllers.md) (controllers). O resultado
-  da execução de uma ação é a resposta que o usuário final receberá.
 
-As ações devem ser declaradas em [controladores](structure-controllers.md). Por
+As actions devem ser declaradas em [controllers](structure-controllers.md). Para manter a simplicidade, você pode declarar a action `cumprimentar` na classe já existente
-motivo de simplicidade, você pode declarar a ação `say` na classe já existente
+`SiteController`. Esse controller está definido no arquivo `controllers/SiteController.php`.
-`SiteController`. Este controlador está definido no arquivo `controllers/SiteController.php`.
+Segue aqui o início da nova action:
-Segue aqui o início da nova ação:
 
 ```php
 <?php
@@ -45,125 +40,116 @@ class SiteController extends Controller
 {
     // ...código existente...
 
-    public function actionSay($message = 'Hello')
+    public function actionCumprimentar($mensagem = 'Olá!')
     {
-        return $this->render('say', ['message' => $message]);
+        return $this->render('cumprimentar', ['mensagem' => $mensagem]);
     }
 }
 ```
 
-No código acima, a ação `say` está definida como um método chamado `actionSay`
+No código acima, a action `cumprimentar` está definida como um método chamado `actionCumprimentar`
-na classe `SiteController`. O Yii usa o prefixo `action` para diferenciar métodos
+na classe `SiteController`. O Yii usa o prefixo `action` para diferenciar os métodos
-de ações de métodos que não são de ações em uma classe de controlador. O nome
+de actions dos métodos que não são de actions em uma classe de controller. O nome após o prefixo `action` é mapeado como o ID da action.
-após o prefixo `action` é mapeado para o ID da ação.
 
-Quando se trata de dar nome às suas ações, você deveria entender como o Yii
+Quando se trata de dar nome às suas actions, você deveria entender como o Yii
-trata os IDs de ações. Os IDs das ações são sempre referenciados em minúsculo.
+trata os IDs de actions. Os IDs de actions são sempre referenciados em minúsculo.
-Se o ID de uma ação necessitar de múltiplas palavras, elas serão concatenadas
+Se o ID de uma action necessitar de múltiplas palavras, elas serão concatenadas
-por hífens (por exemplo, `create-comment`). Os nomes de métodos de ações são mapeados
+por hífens (por exemplo, `criar-comentario`). Os IDs de actions são convertidos em nomes de actions removendo-se os hífens dos IDs, colocando em maiúscula a
-para os IDs das ações removendo-se os hífens dos IDs, colocando em maiúsculo a
 primeira letra de cada palavra, e prefixando o resultado com a palavra `action`. Por exemplo,
-o ID de ação `create-comment` corresponde ao método de ação `actionCreateComment`.
+o ID de action `criar-comentario` corresponde ao método de action `actionCriarComentario`.
 
-O método de ação em nosso exemplo recebe um parâmetro `$message`, cujo valor
+O método da action em nosso exemplo recebe um parâmetro `$mensagem`, cujo valor
-padrão é "Hello" (exatamente da mesma forma que você define um valor padrão para
+padrão é "Olá!" (exatamente da mesma forma que você define um valor padrão para
   qualquer argumento de função ou método no PHP). Quando a aplicação recebe a
-requisição e determina que a ação `say` é responsável por tratar a requisição,
+requisição e determina que a action `cumprimentar` é responsável por tratar a requisição,
-a aplicação alimentará este parâmetro com o parâmetro de mesmo nome encontrado
+a aplicação vai preencher esse parâmetro com o parâmetro que tiver o mesmo nome
-na requisição. Em outras palavras, se a requisição inclui um parâmetro `message`
+na requisição. Em outras palavras, se a requisição inclui um parâmetro `mensagem`
-com o valor `"Goodbye"`, a variável `$message` na ação receberá esse valor.
+com o valor `"Adeus!"`, a variável `$mensagem` na action receberá esse valor.
 
-Dentro do método da ação, [[yii\web\Controller::render()|render()]] é chamado
+Dentro do método da action, [[yii\web\Controller::render()|render()]] é chamado
-para renderizar um arquivo de [visão](structure-views.md) chamado `say`. O
+para renderizar um arquivo de [view](structure-views.md) chamado `cumprimentar`. O
-parâmetro `message` também é passado para a visão de modo que ele possa ser usado
+parâmetro `mensagem` também é passado para a view de modo que ele possa ser usado
-ali. O resultado da renderização é retornado pelo método da ação. Esse resultado
+por ela. O resultado da renderização da view é retornado pelo método da action. Esse resultado
-será recebido pela aplicação, e exibido para o usuário final no navegador (como
+será recebido pela aplicação e exibido para o usuário final no navegador (como parte de uma página HTML completa).
-parte de uma página HTML completa).
 
 
-Criando uma Visão <span id="creating-view"></span>
+Criando uma View <span id="creating-view"></span>
 -----------------
 
-As [visões](structure-views.md) são scripts que você escreve para gerar o conteúdo
+As [views](structure-views.md) são scripts que você escreve para gerar o conteúdo de uma resposta.
-de uma resposta. Para a tarefa "Hello", você criará uma visão `say` que imprime o
+Para a tarefa "Olá!", você criará uma view `cumprimentar` que exibe o parâmetro `mensagem` recebido do método da action:
-parâmetro `message` recebido do método da ação:
 
 ```php
 <?php
 use yii\helpers\Html;
 ?>
-<?= Html::encode($message) ?>
+<?= Html::encode($mensagem) ?>
 ```
 
-A visão `say` deve ser salva no arquivo `views/site/say.php`. Quando o método
+A view `cumprimentar` deve ser salva no arquivo `views/site/cumprimentar.php`. Quando o método
-[[yii\web\Controller::render()|render()]] é chamado em uma ação, ele procurará
+[[yii\web\Controller::render()|render()]] é chamado em uma action, ele procurará
-um arquivo PHP chamado de `views/IDdoController/NomeDaView.php`.
+o arquivo PHP em `views/IDdoController/NomeDaView.php`.
 
-Perceba que no código acima o parâmetro `message` é [[yii\helpers\Html::encode()|codificado como HTML]]
+Perceba que no código acima o parâmetro `mensagem` é [[yii\helpers\Html::encode()|codificado como HTML]]
 antes de ser impresso. Isso é necessário, já que o parâmetro vem de um usuário final,
 tornando-o vulnerável a [ataques de cross-site scripting (XSS)](http://en.wikipedia.org/wiki/Cross-site_scripting)
-onde coloca-se código JavaScript malicioso no parâmetro.
+por embutir código JavaScript malicioso no parâmetro.
 
-Naturalmente, você pode colocar mais conteúdo na visão `say`. O conteúdo pode consistir
+Naturalmente, você pode colocar mais conteúdo na view `cumprimentar`. O conteúdo pode consistir
-de tags HTML, texto puro, ou até mesmo instruções de PHP. De fato a visão `say` é
+de tags HTML, texto puro, ou até mesmo instruções de PHP. De fato, a view `cumprimentar` é
 apenas um script PHP que é executado pelo método [[yii\web\Controller::render()|render()]].
-O conteúdo impresso pelo script da visão será retornado à aplicação como o resultado
+O conteúdo impresso pelo script da view será retornado à aplicação como o resultado
-da resposta. A aplicação, por sua vez, retornará este resultado para o usuário final.
+da resposta. A aplicação, por sua vez, retornará esse resultado para o usuário final.
 
 
-Testando <span id="trying-it-out"></span>
+Conferindo <span id="trying-it-out"></span>
 --------
 
-Após criar a ação e a visão, você pode acessar a nova página através da seguinte URL:
+Após criar a action e a view, você pode acessar a nova página através da seguinte URL:
 
 ```
-http://hostname/index.php?r=site/say&message=Hello+World
+http://hostname/index.php?r=site/cumprimentar&mensagem=Olá+Mundo!
 ```
 
-![Hello World](images/start-hello-world.png)
+![Olá Mundo!](images/start-hello-world.png)
 
-Esta URL resultará em uma página exibindo "Hello World". Esta página compartilha
+Essa URL resultará em uma página exibindo "Olá Mundo!". Essa página compartilha o mesmo cabeçalho e rodapé das outras páginas da aplicação.
-o mesmo cabeçalho e rodapé das outras páginas da aplicação.
 
-Se você omitir o parâmetro `message` na URL, você veria a página exibindo somente
+Se você omitir o parâmetro `mensagem` na URL, você verá a página exibindo somente
-"Hello". Isso é porque `message` é passado como um parâmetro para o método `actionSay()`,
+"Olá!". Isso ocorre por que `mensagem` é passado como um parâmetro para o método `actionCumprimentar()` e,
-e quando ele é omitido, o valor padrão `"Hello"` será usado ao invés dele.
+quando ele é omitido, o valor padrão `"Olá!"` é usado em seu lugar.
 
-> Informação: A nova página compartilha o mesmo cabeçalho e rodapé de outras páginas
+> Info: A nova página compartilha o mesmo cabeçalho e rodapé de outras páginas
-  porque o método [[yii\web\Controller::render()|render()]] irá automaticamente
+  porque o método [[yii\web\Controller::render()|render()]] vai automaticamente
-  incluir o resultado da visão `say` em um [layout](structure-views.md#layouts) 
+  incluir o resultado da view `cumprimentar` em um [layout](structure-views.md#layouts)
   que neste caso está localizado em `views/layouts/main.php`.
 
 O parâmetro `r` na URL acima requer mais explicação. Ele significa [rota](runtime-routing.md),
-um ID abrangente e único de uma aplicação que se refere a uma ação. O formato da rota
+um ID único e amplo de uma aplicação que se refere a uma action. O formato da rota
 é `IDdoController/IDdaAction`. Quando a aplicação recebe uma requisição, ela
-verificará este parâmetro, usando a parte `IDdoController` para determinar qual
+verificará esse parâmetro e usará a parte `IDdoController` para determinar qual
-classe de controlador deve ser instanciada para tratar a requisição. Então o
+classe de controller deve ser instanciada para tratar a requisição. Então o
-controlador usará a parte `IDdaAction` para determinar qual ação deverá ser
+controller usará a parte `IDdaAction` para determinar qual action deverá ser
-instanciada para fazer o trabalho. No caso deste exemplo, a rota `site/say` será
+instanciada para fazer o trabalho. No caso deste exemplo, a rota `site/cumprimentar` será
-resolvida como a classe de controlador `SiteController` e a ação `say`. Como
+resolvida como a classe de controller `SiteController` e a action `cumprimentar`. Como
-resultado, o método `SiteController::actionSay()` será chamado para tratar a requisição.
+resultado, o método `SiteController::actionCumprimentar()` será chamado para tratar a requisição.
 
-> Informação: Assim como as ações, os controladores também possuem IDs que os identificam
+> Info: Assim como as actions, os controllers também possuem IDs que os identificam
-  de maneira única em uma aplicação. Os IDs de controladores seguem as mesmas regras
+  de maneira única em uma aplicação. IDs de controllers seguem as mesmas regras de nomenclatura dos IDs de actions. Os nomes das classes de controlllers
-  de nomenclatura que os IDs de ações. Os nomes das classes de controlllers
+  derivam dos IDs de controllers removendo-se os hífens dos IDs, convertendo a
-  derivam dos IDs de controladores removendo-se os hífens dos IDs, convertendo a
   primeira letra de cada palavra em maiúscula, e adicionando o sufixo `Controller`.
-  Por exemplo, o ID de controlador `post-comment` corresponde ao nome de classe
+  Por exemplo, o ID de controller `comentario-de-artigo` corresponde ao nome de classe
-  de controlador `PostCommentController`.
+  de controller `ComentarioDeArtigoController`.
 
 
 Resumo <span id="summary"></span>
 ------
 
-Nesta seção, você tocou as partes do controlador (controller) e da visão (view)
+Nesta seção, você teve uma introdução sobre as partes controller e view do padrão de arquitetura MVC. Você criou uma action como parte de um controller para tratar uma requisição específica.
-do padrão de arquitetura MVC. Você criou uma ação (action) como parte de um controlador
+E você também criou uma view para compor o conteúdo da resposta. Nesse exemplo simples, nenhum modelo (model) foi
-para tratar uma requisição específica. E você também criou uma visão para compor
+utilizado, já que o único dado exibido foi o parâmetro `mensagem`.
-o conteúdo da resposta. Neste exemplo simples acima, nenhum modelo (model) foi
-utilizado, já que os único dado sendo exibido foi o parâmetro `message`.
 
 Você também aprendeu sobre as rotas no Yii, que agem como a ponte entre as
-requisições do usuário e as ações do controlador.
+requisições de usuário e as actions de controllers.
 
-Na próxima seção, você aprenderá como criar um modelo e adicionar uma nova
+Na próxima seção, você aprenderá como criar um modelo (model) e adicionar uma nova página contendo um formulário HTML.
-página contendo um formulário HTML.

docs/guide-pt-BR/start-looking-ahead.md

@@ -1,44 +1,36 @@
 Seguindo em Frente
 ==================
 
-Se você leu a seção "Primeiros Passos" inteira, você criou uma aplicação Yii
+Se você leu toda a seção "Primeiros Passos", você criou uma aplicação Yii
-completa. Neste processo, você aprendeu como implementar algumas funcionalidades
+completa. No processo, você aprendeu como implementar algumas funcionalidades comumente necessárias, tais como obter dados de usuários através de um formulário
-comumente necessárias, tais como obter dados de usuários através de um formulário
+HTML, consultar dados de um banco de dados e exibir os dados de forma paginada.
-HTML, consultar dados de um banco de dados, e exibir os dados de forma paginada.
 Você também aprendeu a usar o [Gii](tool-gii.md) para gerar código automaticamente.
 Usar o Gii para a geração de código torna a carga do seu processo de desenvolvimento
 Web uma tarefa tão simples quanto preencher alguns formulários.
 
-Esta seção resume as referências sobre o Yii que lhe ajudarão a ser mais produtivo
+Esta seção resume recursos Yii disponíveis que o ajudarão a ser mais produtivo usando o framework.
-usando o framework.
 
 * Documentação
     - [O Guia Definitivo](http://www.yiiframework.com/doc-2.0/guide-README.html):
       Conforme o nome indica, o guia define precisamente como o Yii deve funcionar
-      e fornece orientações gerais sobre como usar o Yii. É o tutorial
+      e fornece orientações gerais sobre como usá-lo. É o tutorial mais importante e que você deveria ler antes de escrever qualquer código Yii.
-      mais importante, e que você deveria ler antes de escrever qualquer código
-      com o Yii.
     - [A Referência de Classes](http://www.yiiframework.com/doc-2.0/index.html):
-      Especifica o uso de todas as classes disponibilizadas pelo Yii. Deve ser
+      Especifica o uso de todas as classes fornecidas pelo Yii. Deve ser
-      principalmente usado quando você estiver escrevendo o código e quiser entender
+      principalmente usada quando você estiver escrevendo código e quiser entender o uso de uma classe, método ou propriedade específicos. O uso da referência
-      o uso de uma classe, método ou propriedade em particular. O uso da referência
+      de classes é idealmente melhor somente depois de um entendimento contextual do framework como um todo.
-      de classes só é melhor depois de um entendimento contextual do framework
+    - [Os Artigos Wiki](http://www.yiiframework.com/wiki/?tag=yii2):
-      inteiro.
+      Os artigos wiki são escritos por usuários do Yii baseados em suas próprias experiências. A maioria deles são escritos como receitas de bolo e mostram
-    - [Os Artigos do Wiki](http://www.yiiframework.com/wiki/?tag=yii2):
+      como resolver problemas específicos usando o Yii. Ainda que a qualidade desses artigos possa não ser tão boa quanto a do Guia Definitivo, eles são úteis porque são abrangem assuntos adicionais e frequentemente fornecem
-      Os artigos do wiki escritos pelos usuários do Yii baseados em suas próprias
-      experiências. A maioria deles são escritos como receitas de bolo, e mostram
-      como resolver problemas em particular usando o Yii. Enquanto a qualidade destes
-      artigos pode não ser tão boa quanto a do Guia Definitivo, eles ainda assim
-      são úteis porque são mais abrangentes e frequentemente fornecem
       soluções prontas para serem usadas.
     - [Livros](http://www.yiiframework.com/doc/)
 * [Extensões](http://www.yiiframework.com/extensions/):
-  O Yii ostenta uma biblioteca de milhares de extensões contribuídas por usuários,
+  O Yii ostenta uma biblioteca de milhares de extensões contribuídas por usuários que podem facilmente ser plugadas em suas aplicações, tornando
-  que podem facilmente ser plugadas em suas aplicações, desta forma tornando
   o seu desenvolvimento ainda mais rápido e mais fácil.
 * Comunidade
     - Fórum: <http://www.yiiframework.com/forum/>
-    - Chat do IRC: O canal #yii na rede freenode (<irc://irc.freenode.net/yii>)
+    - Chat IRC: O canal #yii na rede freenode (<irc://irc.freenode.net/yii>)
+    - Canal Slack: <https://yii.slack.com>
+    - Chat Gitter: <https://gitter.im/yiisoft/yii2>
     - GitHub: <https://github.com/yiisoft/yii2>
     - Facebook: <https://www.facebook.com/groups/yiitalk/>
     - Twitter: <https://twitter.com/yiiframework>

docs/guide-pt-BR/start-workflow.md

@@ -2,20 +2,17 @@ Executando Aplicações
 =====================
 
 Após instalar o Yii, você tem uma aplicação Yii funcional que pode ser acessada
-pela URL `http://hostname/basic/web/index.php` ou `http://hostname/index.php`,
+pela URL `http://hostname/basico/web/index.php` ou `http://hostname/index.php`,
-dependendo da sua configuração. Esta seção introduzirá a funcionalidade embutida
+dependendo de sua configuração. Esta seção introduzirá a funcionalidade embutida
-da aplicação, como o código é organizado, e como a aplicação manuseia as requisições
+da aplicação, como o código é organizado e como a aplicação trata as requisições em geral.
-em geral.
 
 > Info: Por questões de simplicidade, por todo este tutorial de "Primeiros Passos"
-  assume-se que você definiu `basic/web` como a raiz de documentos do seu
+  assume-se que você definiu `basico/web` como a raiz de documentos do seu
   servidor Web e configurou a URL de acesso de sua aplicação como `http://hostname/index.php`
-  ou algo semelhantes. Por favor ajuste as URLs em nossas descrições às suas
+  ou algo semelhante.
-  necessidades.
+  Por favor, ajuste as URLs em nossas descrições conforme necessário.
 
-Observe que ao contrário do próprio framework, após a instalação de um dos templates 
+Observe que, ao contrário do framework em si, após o template de projeto ser instalado, ele é todo seu. Você está livre para adicionar ou remover código e modificar o template conforme precisar.
-de projetos, você está livre para adicionar, remover ou sobrescrever qualquer código
-que precisar.
 
 
 Funcionalidade <span id="functionality"></span>
@@ -27,32 +24,27 @@ O template básico de projetos instalado contém quatro páginas:
 * a página "About" (Sobre),
 * a página "Contact" (Contato), que exibe um formulário de contato que permite
   que usuários finais entrem em contato com você via e-mail,
-* e a página "Login", que exibe um formulário de login que pode ser usado
+* e a página "Login", que exibe um formulário de login que pode ser usado para aurenticar usuários finais.
-  para aurenticar usuários finais. Tente fazer o login com "admin/admin", e
+  Tente fazer o login com "admin/admin", e você perceberá que o item do menu principal "Login" mudará para "Logout".
-  você perceberá que o item do menu principal "Login" mudará para "Logout".
 
-Estas páginas compartilham um cabeçalho e rodapé em comum. O cabeçalho contém
+Essas páginas compartilham o mesmo cabeçalho e rodapé. O cabeçalho contém uma barra de menu principal que permite a navegação entre as diferentes páginas.
-uma barra de menu principal que permite a navegação através das diferentes páginas.
 
 Você também deverá ver uma barra de ferramentas no rodapé da janela do navegador.
-Essa é uma [ferramenta de depuração](tool-debugger.md) fornecida pelo Yii para
+Essa é uma [ferramenta de depuração](tool-debugger.md) muito útil fornecida pelo Yii para
-registrar e exibir várias informações de depuração, tais como mensagens de logs,
+registrar e exibir várias informações de depuração, tais como: mensagens de logs, status de respostas, as consultas de banco de dados executadas, e assim por diante.
-status de respostas, as consultas de banco de dados executadas, e assim por diante.
+
+Além da aplicação Web, existe um script de console chamado `yii`, que está localizado no diretório raiz da aplicação.
+Esse script pode ser usado para executar rotinas em segundo plano e tarefas de manutenção da aplicação que são descritas na seção [Comandos de Console](tutorial-console.md).
 
-Além da aplicação Web, existe um script console chamado `yii`, que está localizado
-na pasta base da aplicação.
-Este script pode ser usado para executar rotinas em segundo plano e tarefas de
-manutenção da aplicação, descritas na [seção Comandos de Console](tutorial-console.md).
 
 Estrutura da Aplicação <span id="application-structure"></span>
 ----------------------
 
-Os diretórios e arquivos mais importantes em sua aplicação são (assumindo que
+Os diretórios e arquivos mais importantes em sua aplicação, assumindo que o diretório raiz dela é o `basico`, são:
-o diretório raiz de sua aplicação é `basic`):
 
 ```
-basic/                  caminho base de sua aplicação
+basico/                  caminho base de sua aplicação
-    composer.json       usado pelo Composer, descreve as informações de pacotes
+    composer.json       usado pelo Composer, descreve informações de pacotes
     config/             contém as configurações da aplicação e outras
         console.php     a configuração da aplicação de console
         web.php         a configuração da aplicação Web
@@ -68,10 +60,8 @@ basic/                  caminho base de sua aplicação
     yii                 o script de execução dos comandos de console do Yii
 ```
 
-Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles em
+Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles em `basico/web` e aqueles em outros diretórios.
-`basic/web` e aqueles em outros diretórios. Os primeiros podem ser acessados
+Os primeiros podem ser acessados diretamente via HTTP (ou seja, em um navegador), enquanto os demais não podem e deveriam ser acessados.
-diretamente via HTTP (ou seja, em um navegador), enquanto os segundos não podem
-e nem deveriam.
 
 O Yii implementa o padrão de arquitetura [modelo-visão-controlador (MVC)](http://wikipedia.org/wiki/Model-view-controller),
 que se reflete na organização de diretórios acima. O diretório `models` contém
@@ -84,36 +74,30 @@ O diagrama a seguir demonstra a estrutura estática de uma aplicação.
 ![Estrutura Estática de uma Aplicação](images/application-structure.png)
 
 Cada aplicação tem um script de entrada `web/index.php` que é o único script PHP
-acessível pela Web na aplicação. O script de entrada recebe uma requisição e
+acessível pela Web na aplicação. O script de entrada recebe uma requisição e cria uma instância de [aplicação](structure-applications.md) para tratar a requisição.
-cria uma instância da [aplicação](structure-applications.md) para gerenciá-la.
+A [aplicação](structure-applications.md) resolve ("traduz") a requisição com a ajuda de seus [componentes](concept-components.md) e despacha a requisição para os elementos do MVC. São usados [Widgets](structure-widgets.md) nas [views](structure-views.md) para ajudar a construir elementos de interface de usuário complexos e dinâmicos.
-A [aplicação](structure-applications.md) resolve a requisição com a ajuda de seus
-[componentes](concept-components.md), e despacha a requisição para os elementos
-do MVC. São usados [Widgets](structure-widgets.md) nas [views](structure-views.md)
-para ajudar a construir elementos de interface de usuário complexos e dinâmicos.
 
 
 Ciclo de Vida da Requisição <span id="request-lifecycle"></span>
 ---------------------------
 
-O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
+O diagrama a seguir demonstra como uma aplicação trata uma requisição.
 
 ![Ciclo de Vida da Requisição](images/request-lifecycle.png)
 
 1. Um usuário faz uma requisição ao [script de entrada](structure-entry-scripts.md) `web/index.php`.
 2. O script de entrada carrega a [configuração](concept-configurations.md) da
-   aplicação e cria uma instância da [aplicação](structure-applications.md) para
+   aplicação e cria uma instância de [aplicação](structure-applications.md) para
-   gerenciar a requisição.
+   tratar a requisição.
-3. A aplicação resolve a [rota](runtime-routing.md) solicitada com a ajuda do
+3. A aplicação resolve ("traduz") a [rota](runtime-routing.md) solicitada com a ajuda do componente [request](runtime-requests.md) da aplicação.
-   componente de aplicação [request](runtime-requests.md).
 4. A aplicação cria uma instância de um [controller](structure-controllers.md)
-   para gerenciar a requisição.
+   para tratar a requisição.
-5. O controller cria uma instância de um [action](structure-controllers.md) (ação)
+5. O controller cria uma instância de uma [action](structure-controllers.md) (ação) e aplica os filtros para a ação.
-   e aplica os filtros para a ação.
 6. Se qualquer filtro falhar, a ação é cancelada.
 7. Se todos os filtros passarem, a ação é executada.
-8. A ação carrega um modelo de dados, possivelmente a partir de um banco de dados.
+8. A ação carrega alguns modelos (models) de dados, possivelmente a partir de um banco de dados.
-9. A ação renderiza uma view, fornecendo a ela o modelo de dados.
+9. A ação renderiza uma view, passando a ela os modelos de dados.
-10. O resultado renderizado é retornado pelo componente de aplicação
+10. O resultado renderizado é retornado pelo componente
-    [response](runtime-responses.md) (resposta).
+    [response](runtime-responses.md) (resposta) da aplicação.
-11. O componente *response* envia o resultado renderizado para o navegador do usuário.
+11. O componente response envia o resultado renderizado para o navegador do usuário.
 

docs/guide/start-hello.md

@@ -54,7 +54,7 @@ The name after the `action` prefix maps to the action's ID.
 
 When it comes to naming your actions, you should understand how Yii treats action IDs. Action IDs are always
 referenced in lower case. If an action ID requires multiple words, they will be concatenated by dashes
-(e.g., `create-comment`). Action method names are mapped to action IDs by removing any dashes from the IDs,
+(e.g., `create-comment`). Action method IDs are mapped to action names by removing any dashes from the IDs,
 capitalizing the first letter in each word, and prefixing the resulting string with `action`. For example,
 the action ID `create-comment` corresponds to the action method name `actionCreateComment`.