lucasts
diff --git a/‎pt_BR/guides/security/authorization.rst
Copy file name to clipboardExpand all lines: pt_BR/guides/security/authorization.rst
+23-23Lines changed: 23 additions & 23 deletions b/‎pt_BR/guides/security/authorization.rst
Copy file name to clipboardExpand all lines: pt_BR/guides/security/authorization.rst
+23-23Lines changed: 23 additions & 23 deletions
diff --git a/‎pt_BR/guides/validator/constraints.rst
Copy file name to clipboardExpand all lines: pt_BR/guides/validator/constraints.rst
+50-51Lines changed: 50 additions & 51 deletions b/‎pt_BR/guides/validator/constraints.rst
Copy file name to clipboardExpand all lines: pt_BR/guides/validator/constraints.rst
+50-51Lines changed: 50 additions & 51 deletions
diff --git a/‎pt_BR/guides/validator/overview.rst
Copy file name to clipboardExpand all lines: pt_BR/guides/validator/overview.rst
+22-22Lines changed: 22 additions & 22 deletions b/‎pt_BR/guides/validator/overview.rst
Copy file name to clipboardExpand all lines: pt_BR/guides/validator/overview.rst
+22-22Lines changed: 22 additions & 22 deletions
diff --git a/‎pt_BR/guides/validator/validation.rst
Copy file name to clipboard
+16-17Lines changed: 16 additions & 17 deletions b/‎pt_BR/guides/validator/validation.rst
Copy file name to clipboard
+16-17Lines changed: 16 additions & 17 deletions
@@ -1,23 +1,23 @@
 .. index::
    single: Security; Authorization
 
-Authorization
-=============
+Autorização
+===========
 
-When the user is authenticated, you can restrict access to your application
-resources via access control rules. Authorization in Symfony2 covers this need
-but it also provides a standard and powerful way to decide if a user can
-access any resource (a URL, a model object, a method call, ...) thanks to a
-flexible access decision manager.
+Quando o usuários estiver autenticado, você pode restringir o acesso aos recursos
+da sua aplicação usando regras de controle de acesso. A Autorização no Symfony2 
+cobre essa necessidade mas também provê uma maneira padrão e poderosa de decidir
+se o usuário pode acessar algum recurso (uma URL, um model, uma chamada de método, ...)
+graças a um flexível gerenciador de decisão de acesso.
 
 .. index::
    single: Security; Access Control
 
-Defining Access Control Rules for HTTP resources
-------------------------------------------------
+Definindo Regras de Controle de Acesso para Recursos HTTP
+---------------------------------------------------------
 
-Authorization is enforced for each request, based on access control rules
-defined in your configuration:
+A Autorização é executada para cara requisição, baseada nas regras de controle
+de acesso definidas na sua configuração:
 
 .. configuration-block::
 
@@ -49,21 +49,21 @@ defined in your configuration:
             ),
         ));
 
-For each incoming request, Symfony2 tries to find a matching access control
-rule (the first one wins) and throws an
-:class:`Symfony\\Component\Security\\Exception\\AccessDeniedException` if the
-user has not the needed roles or an
+Para cara requisição que chega, o Symfony2 tenta encontrar uma regra de controle de acesso
+que case (a primeira a casar é escolhida) e dispara uma 
+:class:`Symfony\\Component\Security\\Exception\\AccessDeniedException` se o usuário não tiver 
+as permissões necessárias ou uma 
 :class:`Symfony\\Component\Security\\Exception\\AuthenticationCredentialsNotFoundException`
-if he is not authenticated yet.
+se o usuário não estiver autenticado ainda.
 
-In the example above, we match requests based on their path info, but there
-are many other ways as you will learn in the next section.
+No exemplo acima, nós comparamos as requisições basiadas nas informações do path, mas
+tem várias outras maneiras que você vai aprender nessa seção.
 
 ..tip::
 
-    Symfony2 automatically adds a special role based on the anonymous flag:
-    ``IS_AUTHENTICATED_ANONYMOUSLY`` for anonymous users and
-    ``IS_AUTHENTICATED_FULLY`` for all others.
+    O Symfony2 automaticamente adiciona uma role especial baseada na flag anônima:
+    ``IS_AUTHENTICATED_ANONYMOUSLY`` para usuários anônimos e
+    ``IS_AUTHENTICATED_FULLY`` para todos os outros.
 
 Matching a Request
 ------------------
@@ -131,8 +131,8 @@ Access control rules can match a request in many different ways:
 .. index::
    single: Security; HTTPS
 
-Enforcing HTTP or HTTPS
------------------------
+Executando HTTP ou HTTPS
+------------------------
 
 Besides roles, you can also force parts of your website to use either HTTP or
 HTTPS:
 
@@ -1,15 +1,15 @@
-Constraints
-===========
+Restrições
+==========
 
-The Validator is designed to validate objects against *constraints*.
-In real life, a constraint could be: "The cake must not be burned". In
-Symfony2, constraints are similar: They are assertions that a condition is 
-true.
+O Validator é projetado para validar objetos com as *restrições*.
+Na vida real, uma restrição pode ser: "O bolo não deve estar queimado". No 
+Symfony2, restrições são similares: Elas são afirmações de que a condição
+é verdadeira.
 
-Supported Constraints
+Restrições Suportadas
 ---------------------
 
-The following constraints are natively available in Symfony2:
+As seguintes restrições são nativamente suportadas pelo Symfony2:
 
 .. toctree::
     :hidden:
@@ -36,20 +36,21 @@ The following constraints are natively available in Symfony2:
 * :doc:`Url <constraints/Url>`
 * :doc:`Valid <constraints/Valid>`
 
-Constraint Targets
-------------------
+Alvos das Restrições
+--------------------
 
-Constraints can be put on properties of a class, on public getters and on the
-class itself. The benefit of class constraints is that they can validate
-the whole state of an object at once, with all of its properties and methods.
+Restrições podem ser colocadas em propriedades de uma classe, em getter publicos
+e na própria classe. Os beneficios de restrições em classes é que elas podem
+valida o estado inteiro de um objeto de uma só vez, com todas as suas propriedades
+ e métodos.
 
-Properties
-~~~~~~~~~~
+Propriedades
+~~~~~~~~~~~~
 
-Validating class properties is the most basic validation technique. Symfony2
-allows you to validate private, protected or public properties. The next
-listing shows how to configure the properties ``$firstName`` and ``$lastName``
-of a class ``Author`` to have at least 3 characters.
+A validação de propriedades de uma classe é a mais básica das técnicas de validação.
+O Symfony2 permite que você valide propriedades privadas, protegidas ou públicas. A
+lista a seguir mostra como configurar as propriedades ``$firstName`` e ``$lastName``
+da classe ``Author`` para ter no mínimo 3 caracteres.
 
 .. configuration-block::
 
@@ -100,17 +101,17 @@ of a class ``Author`` to have at least 3 characters.
 Getters
 ~~~~~~~
 
-The next validation technique is to constrain the return value of a method.
-Symfony2 allows you to constrain any public method whose name starts with
-"get" or "is". In this guide, this is commonly referred to as "getter".
+A próxima técnica de validação é restringir o valor do retorno de um método.
+O Symfony2 permite que você restrinja qualquer método público em que o nome
+comece com "get" ou "is". Nesse guia, ele é referenciado como "getter".
 
-The benefit of this technique is that it allows you to validate your object
-dynamically. Depending on the state of your object, the method may return
-different values which are then validated.
+O beneficio dessa técnica é que ela permite você validar seu objeto dinamicamente.
+Dependendo do estato do seu objeto, o método pode retornar diferentes valores que
+então são validados.
 
-The next listing shows you how to use the :doc:`AssertTrue
-<constraints/AssertTrue>` constraint to validate whether a dynamically
-generated token is correct:
+A lista a seguir mostra como usar a restrição :doc:`AssertTrue
+<constraints/AssertTrue>` para validar se um token gerado dinamicamente está 
+correto:
 
 .. configuration-block::
 
@@ -149,19 +150,18 @@ generated token is correct:
 
 .. note::
 
-    The keen-eyed among you will have noticed that the prefix of the getter 
-    ("get" or "is") is omitted in the mapping. This allows you to move the
-    constraint to a property with the same name later (or vice versa) without
-    changing your validation logic.
+    Se você tem uma visão aguçada, deve ter percebido que o prefixo do getter
+    ("get" ou "is") foi omitido do mapeamento. Isso permite que você mova a 
+    restrição para uma propriedade com o mesmo nome depois (ou vice-versa)
+    sem mudar a lógica de validação.
 
-Custom Constraints
-------------------
+Restrições Customizadas
+-----------------------
 
-You can create a custom constraint by extending the base constraint class,
-:class:`Symfony\\Component\\Validator\\Constraint`. Options for your
-constraint are represented by public properties on the constraint class. For
-example, the ``Url`` constraint includes ``message`` and ``protocols``
-properties::
+Você pode criar restrições customizadas estendendo a classe base de restrições
+:class:`Symfony\\Component\\Validator\\Constraint`. As opções das suas restrições
+são representadas como propriedades públicas na classe de restrição. Por exemplo,
+a restrição ``Url`` inclui as propriedades ``message`` e ``protocols``::
 
     namespace Symfony\Component\Validator\Constraints;
 
@@ -171,24 +171,24 @@ properties::
         public $protocols = array('http', 'https', 'ftp', 'ftps');
     }
 
-As you can see, a constraint class is fairly minimal. The actual validation is
-performed by a another "constraint validator" class. Which constraint
-validator is specified by the constraint's ``validatedBy()`` method, which
-includes some simple default logic::
+Como você pode ver, uma classe de restrição é bem minima. A validação mesmo é
+feita por outra classe "validadora de restrições". Que validador de restrição
+é especificado pelo método ``validatedBy()``, que inclui alguma lógica simples 
+por padrão::
 
     // in the base Symfony\Component\Validator\Constraint class
     public function validatedBy()
     {
         return get_class($this).'Validator';
     }
 
-Constraint Validators with Dependencies
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Validadores de Restrição com Dependencias
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-If your constraint validator has dependencies, such as a database connection,
-it will need to be configured as a service in the dependency injection
-container. This service must include the ``validator.constraint_validator``
-tag and an ``alias`` attribute:
+Se o se validador de restrição tiver dependencias, como conexão com o banco,
+ele precisará ser configurado como um serviço no container de dependency injection.
+Esse serviço deve incluir a tag ``validator.constraint_validator`` e um atributo
+``alias``:
 
 .. configuration-block::
 
@@ -214,8 +214,7 @@ tag and an ``alias`` attribute:
             ->addTag('validator.constraint_validator', array('alias' => 'alias_name'))
         ;
 
-Your constraint class may now use this alias to reference the appropriate
-validator::
+Suas classes de restrição podem agora usar alias para referenciar o validador apropriado::
 
     public function validatedBy()
     {
 
@@ -1,27 +1,28 @@
-The Validator
-=============
+O Validator
+===========
 
-Validation is a very common task in web applications. Data entered in forms
-needs to be validated. Data also needs to be validated before it is written
-into a database or passed to a web service.
+Validação é uma tarefa muito comum em aplicações web. O conteúdo informado
+nos formulários precisa ser validado. Esse conteúdo também precisa ser validado
+antes de ser gravado em banco de dados ou encaminhado para um web service;
 
-Symfony2 ships with a Validator component that makes this task very easy. This
-component is based on the `JSR303 Bean Validation specification`_. What? A
-Java specification in PHP? You heard right, but it's not as bad as it sounds.
-Let's look at how we use it in PHP.
+O Symfony2 vem com um componente embarcado chamado Validator, que faz essa 
+tarefa ser muito simples. Esse componente é baseado na 
+`JSR303 Bean Validation specification`_. O que?? Uma especificação Java no PHP?
+Você ouviu certo, mas não é tão ruim quanto parece. Vamos ver como nós usamos isso
+em PHP.
 
-The validator validates objects against :doc:`constraints <constraints>`.
-Let's start with the simple constraint that the ``$name`` property of a class
-``Author`` must not be empty::
+O validator valida os objetos com as :doc:`restrições <constraints>`.
+Vamos começar com uma restrição simples que a propriedade ``$name`` da classe
+``Author`` não deve ser vazia::
 
     // Application/HelloBundle/Author.php
     class Author
     {
         private $name;
     }
 
-The next listing shows the configuration that connects properties of the class
-with constraints; this process is called the "mapping":
+A próxima lista, mostra a configuração que conecta as propriedades da classe com
+as restrições; esse processo é chamado de "mapeamento":
 
 .. configuration-block::
 
@@ -53,9 +54,9 @@ with constraints; this process is called the "mapping":
             private $name;
         }
 
-Finally, we can use the :class:`Symfony\\Component\\Validator\\Validator`
-class for :doc:`validation <validation>`. To use the default Symfony2
-validator, adapt your application configuration as follows:
+Finalmente, nós pomos usar a classe :class:`Symfony\\Component\\Validator\\Validator`
+para :doc:`validar <validation>`. Para usar a validator padrão do Symfony2, adapte 
+sua aplicação assim:
 
 .. code-block:: yaml
 
@@ -64,8 +65,8 @@ validator, adapt your application configuration as follows:
         validation:
             enabled: true
 
-Now call the ``validate()`` method on the service, which delivers a list of
-errors if validation fails.
+Agora chame o método ``validate()`` no serviço, que entrega uma lista de erros caso
+a validação falhe.
 
 .. code-block:: php
 
@@ -74,14 +75,13 @@ errors if validation fails.
 
     print $validator->validate($author);
 
-Because the ``$name`` property is empty, you will see the following error
-message:
+Por a propriedade ``$name`` estar vazia, você vai ver a seguinte mensagem de erro:
 
 .. code-block:: text
 
     Application\HelloBundle\Author.name:
         This value should not be blank
 
-Insert a value into the property and the error message will disappear.
+Insira um valor na propriedade e a mensagem de erro vai sumir.
 
 .. _JSR303 Bean Validation specification: http://jcp.org/en/jsr/detail?id=303
@@ -1,11 +1,10 @@
-Constraint Validation
-=====================
+Validação de Restrições
+=======================
 
-Objects with constraints are validated by the
-:class:`Symfony\\Component\\Validator\\Validator` class. If you use Symfony2,
-this class is already registered as a service in the Dependency Injection
-Container. To enable the service, add the following lines to your
-configuration:
+Objetos com restrições são validados pela classe 
+:class:`Symfony\\Component\\Validator\\Validator`. Se você usa o Symfony2, essa
+classe já esta registrada como um serviço do Container Dependency Injection. 
+Para habilitar o serviço, adicione as seguintes linhas na sua configuração:
 
 .. code-block:: yaml
 
@@ -14,22 +13,22 @@ configuration:
         validation:
             enabled: true
 
-Then you can get the validator from the container and start validating your
-objects::
+Então você pode pegar o validador do container e começar a validar seus 
+objetos::
 
     $validator = $container->getService('validator');
     $author = new Author();
 
     print $validator->validate($author);
 
-The ``validate()`` method returns a
-:class:`Symfony\\Component\\Validator\\ConstraintViolationList` object. This
-object behaves exactly like an array. You can iterate over it and you can even
-print it in a nicely formatted manner. Every element of the list corresponds
-to one validation error. If the list is empty, it's time to dance, because
-then validation succeeded.
+O método ``validate()`` retorna um objeto
+:class:`Symfony\\Component\\Validator\\ConstraintViolationList`. Esse objeto
+se comporta exatamente como um array. Você pode percorre-lo e até mesmo 
+imprimi-lo formatado de uma maneira bem agradável. Todo elemento da lista 
+corresponde a um erro de validação. Se a lista estiver vazia, é hora de dançar,
+porque a validação foi bem sucedida.
 
-The above call will output something similar to this:
+A chamada assima vai mostrar algo similar a isso:
 
 .. code-block:: text
 
@@ -40,4 +39,4 @@ The above call will output something similar to this:
     Application\HelloBundle\Author.fullName:
         This value is too short. It should have 10 characters or more
 
-If you fill the object with correct values the validation errors disappear.
+Se o preencher o objeto com os valores corretoes, os erros de validação desaparecem.