gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore(i18n,docs): processed translations (#43005)

Browse Source
This commit is contained in:
camperbot
2021-07-26 02:25:49 +09:00
committed by GitHub
parent c5963374cb
commit f938a9cf98
14 changed files with 645 additions and 645 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
docs/i18n/portuguese/codebase-best-practices.md
View File

@ -1,34 +1,34 @@
# Codebase Best Practices
# Práticas recomendadas da base de código
## General JavaScript
## JavaScript em geral
In most cases, our [linter](how-to-setup-freecodecamp-locally?id=follow-these-steps-to-get-your-development-environment-ready) will warn of any formatting which goes against this codebase's preferred practice.
Na maioria dos casos, nosso [linter](how-to-setup-freecodecamp-locally?id=follow-these-steps-to-get-your-development-environment-ready) avisará sobre qualquer formatação que contradiga as práticas recomendadas desta base de código.
It is encouraged to use functional components over class-based components.
Recomendamos o uso de componentes funcionais em vez de componentes baseados em classes.
## Specific TypeScript
## TypeScript em específico
### Migrating a JavaScript File to TypeScript
### Migração de um arquivo JavaScript para TypeScript
#### Retaining Git File History
#### Manutenção do histórico de arquivos do Git
Sometimes changing the file from `<filename>.js` to `<filename>.ts` (or `.tsx`) causes the original file to be deleted, and a new one created, and other times the filename just changes - in terms of Git. Ideally, we want the file history to be preserved.
Algumas vezes, alterar o arquivo de `<filename>.js` para `<filename>.ts` (ou `.tsx`) faz com que o arquivo original seja excluído e que um novo arquivo seja criado. Em outras situações simplesmente muda – nos termos do Git. O ideal é preservarmos o histórico dos arquivos.
The best bet at achieving this is to:
A melhor maneira de conseguir isso é:
1. Rename the file
2. Commit with the flag `--no-verify` to prevent Husky from complaining about the lint errors
3. Refactor to TypeScript for migration, in a separate commit
1. Renomear o arquivo
2. Fazer o commit com a flag `--no-verify` para evitar que o Husky reclame de erros de lint
3. Refatorar o TypeScript para migração em um commit em separado
> [!NOTE] Editors like VSCode are still likely to show you the file has been deleted and a new one created. If you use the CLI to `git add .`, then VSCode will show the file as renamed in stage
> [!NOTE] Editores como o VSCode provavelmente mostrarão a você que o arquivo foi excluído e que um novo arquivo foi criado. Se você utilizar a CLI para `git add .`, o VSCode mostrará o arquivo como renomeado na fase de stage
### Naming Conventions
### Convenções de nomes
#### Interfaces and Types
#### Interfaces e tipos
For the most part, it is encouraged to use interface declarations over type declarations.
Na maioria dos casos, recomendamos usar declarações de interface em vez de declarações de tipo.
React Component Props - suffix with `Props`
Props de componentes do React – sufixo com `Props`
```typescript
interface MyComponentProps {}
@ -36,7 +36,7 @@ interface MyComponentProps {}
const MyComponent = (props: MyComponentProps) => {};
```
React Stateful Components - suffix with `State`
Componentes stateful do React – sufixo com `State`
```typescript
interface MyComponentState {}
@ -44,7 +44,7 @@ interface MyComponentState {}
class MyComponent extends Component<MyComponentProps, MyComponentState> {}
```
Default - object name in PascalCase
Padrão – nome do objeto em PascalCase
```typescript
interface MyObject {}
@ -58,7 +58,7 @@ const myObject: MyObject = {};
## Redux
### Action Definitions
### Definições de ações
```typescript
enum AppActionTypes = {
@ -73,12 +73,12 @@ export const actionFunction = (
});
```
### How to Reduce
### Como fazer a redução
```typescript
// Base reducer action without payload
// Ação de redução de base sem payload
type ReducerBase<T> = { type: T };
// Logic for handling optional payloads
// Lógica para lidar com os payloads opcionais
type ReducerPayload<T extends AppActionTypes> =
T extends AppActionTypes.actionFunction
? ReducerBase<T> & {
@ -86,7 +86,7 @@ type ReducerPayload<T extends AppActionTypes> =
}
: ReducerBase<T>;
// Switch reducer exported to Redux combineReducers
// Trocar o redutor exportado pelos combineReducers do Redux
export const reducer = (
state: AppState = initialState,
action: ReducerPayload<AppActionTypes>
@ -100,23 +100,23 @@ export const reducer = (
};
```
### How to Dispatch
### Como fazer o dispatch
Within a component, import the actions and selectors needed.
Em um componente, importe as ações e os seletores necessários.
```tsx
// Add type definition
// Adicione a definição de tipo
interface MyComponentProps {
actionFunction: typeof actionFunction;
}
// Connect to Redux store
// Conecte à store do Redux
const mapDispatchToProps = {
actionFunction
};
// Example React Component connected to store
// Exemplo de componente do React conectado à store
const MyComponent = ({ actionFunction }: MyComponentProps): JSX.Element => {
const handleClick = () => {
// Dispatch function
// Função de dispatch
actionFunction();
};
return <button onClick={handleClick}>freeCodeCamp is awesome!</button>;
@ -128,7 +128,7 @@ export default connect(null, mapDispatchToProps)(MyComponent);
<!-- ### Redux Types File -->
<!-- The types associated with the Redux store state are located in `client/src/redux/types.ts`... -->
## Further Literature
## Mais informações
- [TypeScript Docs](https://www.typescriptlang.org/docs/)
- [TypeScript with React CheatSheet](https://github.com/typescript-cheatsheets/react#readme)
- [Documentação do TypeScript](https://www.typescriptlang.org/docs/)
- [TypeScript com a cheatsheet do React](https://github.com/typescript-cheatsheets/react#readme)

370
docs/i18n/portuguese/devops.md
View File

@ -1,48 +1,48 @@
# DevOps Handbook
# Manual do DevOps
This guide will help you understand our infrastructure stack and how we maintain our platforms. While this guide does not have exhaustive details for all operations, it could be used as a reference for your understanding of the systems.
Este guia irá ajudá-lo a entender nossas ferramentas de infraestrutura e como mantemos nossas plataformas. Embora este guia não tenha muitos detalhes para todas as operações, ele pode ser usado como referência para a compreensão dos sistemas.
Fale com a gente, se você tiver algum comentário ou dúvidas, e teremos prazer em esclarecê-las.
# Flight Manual - Code deployments
# Manual de Voo - Implementação de Código
This repository is continuously built, tested and deployed to **separate sets of infrastructure (Servers, Databases, CDNs, etc.)**.
Este repositório é continuamente construído, testado e implementado em **conjuntos separados de infraestrutura (servidores, base de dados, CDNs, etc.)**.
This involves three steps to be followed in sequence:
Isto implica três passos a serem seguidos em sequência:
1. New changes (both fixes and features) are merged into our primary development branch (`main`) via pull requests.
2. These changes are run through a series of automated tests.
3. Once the tests pass we release the changes (or update them if needed) to deployments on our infrastructure.
1. Novas alterações (sejam consertos ou funcionalidades) são mergeadas na nossa branch principal de desenvolvimento (`main`) por meio de pull requests.
2. Estas alterações são executadas por uma série de testes automatizados.
3. Uma vez que os testes passem, liberamos as alterações (ou as atualizamos se necessário) para implementações na nossa infraestrutura.
#### Compilando a base de código - mapeando branches do Git para implementações.
Normalmente, é feito um merge de [`main`](https://github.com/freeCodeCamp/freeCodeCamp/tree/main) (branch padrão de desenvolvimento) na branch [`production-staging`](https://github.com/freeCodeCamp/freeCodeCamp/tree/prod-staging) uma vez ao dia e liberada em uma infraestrutura isolada.
This is an intermediate release for our developers and volunteer contributors. É também conhecida como a nossa versão de "preparo" (staging) ou "beta".
Esta é uma versão intermediária para nossos desenvolvedores e colaboradores voluntários. É também conhecida como a nossa versão de "preparo" (staging) ou "beta".
Ela é idêntica ao nosso ambiente de produção em `freeCodeCamp.org`, tirando o fato de ela usar um conjunto separado de bancos de dados, servidores, web-proxies, etc. Este isolamento nos permite testar o desenvolvimento e as funcionalidades de forma contínua em um cenário semelhante ao de "produção", sem que os usuários regulares da plataforma principal do freeCodeCamp.org sejam afetados.
Uma vez que a equipe de desenvolvedores [`@freeCodeCamp/dev-team`](https://github.com/orgs/freeCodeCamp/teams/dev-team/members) esteja feliz com as mudanças na plataforma de preparo, essas alterações são movidas a cada poucos dias para a branch [`production-current`](https://github.com/freeCodeCamp/freeCodeCamp/tree/prod-current).
This is the final release that moves changes to our production platforms on freeCodeCamp.org.
Esta é a versão final que move as mudanças para as nossas plataformas de produção no freeCodeCamp.org.
#### Testando alterações - Teste de integração e de aceitação do usuário.
We employ various levels of integration and acceptance testing to check on the quality of the code. All our tests are done through software like [GitHub Actions CI](https://github.com/freeCodeCamp/freeCodeCamp/actions) and [Azure Pipelines](https://dev.azure.com/freeCodeCamp-org/freeCodeCamp).
Empregamos vários níveis de testes de integração e aceitação para verificar a qualidade do código. Todos os nossos testes são feitos através de software como [GitHub Actions CI](https://github.com/freeCodeCamp/freeCodeCamp/actions) e [Azure Pipelines](https://dev.azure.com/freeCodeCamp-org/freeCodeCamp).
Temos testes unitários para nossas soluções de desafio, APIs do servidor e interfaces de usuário e cliente. These help us test the integration between different components.
Temos testes unitários para nossas soluções de desafio, APIs do servidor e interfaces de usuário e cliente. Eles nos ajudam a testar a integração entre diferentes componentes.
> [!NOTE] We are also in the process of writing end user tests which will help in replicating real world scenarios like updating an email or making a call to the API or third-party services.
> [!NOTE] Também estamos escrevendo testes de usuário finais que ajudarão a replicar cenários do mundo real, como atualizar um e-mail ou fazer uma chamada para a API ou serviços de terceiros.
Juntos, esses testes ajudam a evitar que problemas se repitam e garantem que não introduzimos um erro enquanto trabalhamos em outra falha ou recurso.
#### Deploying Changes - Pushing changes to servers.
#### Implementando alterações - Enviando alterações para os servidores.
We have configured continuous delivery software to push changes to our development and production servers.
Nós configuramos software de entrega contínua para fazer push de mudanças no nosso servidor de desenvolvimento e produção.
Uma vez que as alterações são enviadas para as branches de lançamento protegidas, um pipeline de construção é automaticamente acionado para a branch. Os pipelines de compilação são responsáveis pela compilação de artefatos e os guardam em um armazenamento de longo prazo para uso posterior.
O pipeline de compilação aciona um correspondente pipeline de lançamento se ele completar uma execução bem-sucedida. The release pipelines are responsible for collecting the build artifacts, moving them to the servers and going live.
O pipeline de compilação aciona um correspondente pipeline de lançamento se ele completar uma execução bem-sucedida. Os pipelines de lançamento são responsáveis por coletar os artefatos de compilação, movendo-os para os servidores e deixando-os disponíveis para acesso.
Estado de compilações e lançamentos estão [disponíveis aqui](#build-test-and-deployment-status).
@ -54,13 +54,13 @@ Atualmente, somente membros da equipe de desenvolvedores podem dar push nas bran
### Enviando alterações para aplicações em fase de preparo.
1. Configure your remotes correctly.
1. Configure seus remotes corretamente.
```sh
git remote -v
```
**Results:**
**Resultados:**
```
origin git@github.com:raisedadead/freeCodeCamp.git (fetch)
@ -77,9 +77,9 @@ Atualmente, somente membros da equipe de desenvolvedores podem dar push nas bran
git reset --hard upstream/main
```
3. Check that the GitHub CI is passing on the `main` branch for upstream.
3. Verifique se a IC do GitHub está passando a branch `main` para o upstream.
The [continuous integration](https://github.com/freeCodeCamp/freeCodeCamp/actions) tests should be green and PASSING for the `main` branch. Clique na marca de verificação verde próximo ao hash do commit quando estiver visualizando o código da branch `main`.
Os testes de [integração contínua](https://github.com/freeCodeCamp/freeCodeCamp/actions) devem estar verdes e PASSANDO para a branch `main`. Clique na marca de verificação verde próximo ao hash do commit quando estiver visualizando o código da branch `main`.
<details> <summary> Verificando o status no GitHub Actions (captura de tela) </summary>
<br>
@ -102,20 +102,20 @@ Atualmente, somente membros da equipe de desenvolvedores podem dar push nas bran
git push upstream
```
> [!NOTE] You will not be able to force push and if you have re-written the history in anyway these commands will error out.
> [!NOTE] Você não será capaz de dar um force push, e se houver reescrito o histórico de alguma forma, esses comandos vão falhar.
>
> If they do, you may have done something incorrectly and you should just start over.
> Se isso acontecer, pode ser que você tenha feito algo errado e você deve simplesmente começar de novo.
As etapas acima vão disparar automaticamente uma execução no pipeline de compilação para a branch `production-staging`. Quando a compilação estiver completa, os artefatos são salvos como arquivos `.zip` em um armazenamento de longo prazo para serem recuperados e usados mais tarde.
O pipeline de lançamento é acionado automaticamente quando um novo artefato estiver disponível a partir do pipeline de compilação conectado. For staging platforms, this process does not involve manual approval and the artifacts are pushed to the Client CDN and API servers.
O pipeline de lançamento é acionado automaticamente quando um novo artefato estiver disponível a partir do pipeline de compilação conectado. Para plataformas de staging, este processo não envolve aprovação manual e os artefatos são empurrados para os servidores de CDN do cliente e API.
### Enviando alterações para aplicações de produção.
O processo é quase o mesmo das plataformas de preparo, com algumas verificações extras. This is just to make sure, we do not break anything on freeCodeCamp.org which can see hundreds of users using it at any moment.
O processo é quase o mesmo das plataformas de preparo, com algumas verificações extras. Só para garantir, não quebramos nada no freeCodeCamp.org que possa ver centenas de usuários usá-lo a qualquer momento.
| Do NOT execute these commands unless you have verified that everything is working on the staging platform. Você não deve ignorar qualquer teste na fase de preparo antes de prosseguir. |
|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| NÃO execute esses comandos a menos que tenha verificado que tudo está funcionando na plataforma de preparo. Você não deve ignorar qualquer teste na fase de preparo antes de prosseguir. |
|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| |
1. Garanta que sua branch `prod-staging` esteja impecável e sincronizada com a upstream.
@ -134,7 +134,7 @@ O processo é quase o mesmo das plataformas de preparo, com algumas verificaçõ
git push upstream
```
> [!NOTE] You will not be able to force push and if you have re-written the history in anyway these commands will error out.
> [!NOTE] Você não será capaz de forçar o push e, se você reescreveu o histórico de qualquer forma, esses comandos irão falhar.
>
> Se falharem, você pode ter feito algo errado e deve começar de novo.
@ -142,14 +142,14 @@ As etapas acima vão disparar automaticamente uma execução no pipeline de comp
**Etapas adicionais para a equipe**
One a release run is triggered, members of the developer staff team will receive an automated manual intervention email. Eles podem _aprovar_ ou _rejeitar_ o release run.
Um release run é acionado, membros da equipe de desenvolvedores receberão um e-mail manual de intervenção automático. Eles podem _aprovar_ ou _rejeitar_ o release run.
If the changes are working nicely and have been tested on the staging platform, then it can be approved. The approval must be given within 4 hours of the release being triggered before getting rejected automatically. A staff can re-trigger the release run manually for rejected runs, or wait for the next cycle of release.
Se as alterações estão funcionando bem e foram testadas na plataforma de preparo, então podem ser aprovadas. A aprovação deve ser dada no prazo de 4 horas após a liberação ser acionada antes de ser automaticamente rejeitada. Uma equipe pode acionar novamente a execução de lançamento manualmente para execuções rejeitadas ou esperar pelo próximo ciclo de lançamento.
For staff use:
Para uso de funcionários:
| Check your email for a direct link or [go to the release dashboard](https://dev.azure.com/freeCodeCamp-org/freeCodeCamp/_release) after the build run is complete. |
|:------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Verifique seu e-mail para obter um link direto ou [vá para o painel de liberação](https://dev.azure.com/freeCodeCamp-org/freeCodeCamp/_release) depois que a execução da compilação estiver concluída. |
|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| |
Uma vez que um dos membros da equipe aprovar o lançamento, as mudanças serão feitas nos servidores CDN e API da produção do freeCodeCamp.org.
@ -165,7 +165,7 @@ Aqui está o estado atual de teste, compilação e implantação do código.
| [`prod-current`](https://github.com/freeCodeCamp/freeCodeCamp/tree/prod-staging) | [![Node.js CI](https://github.com/freeCodeCamp/freeCodeCamp/workflows/Node.js%20CI/badge.svg?branch=prod-current)](https://github.com/freeCodeCamp/freeCodeCamp/actions?query=workflow%3A%22Node.js+CI%22+branch%3Aprod-current) | [![Testes Cypress E2E](https://img.shields.io/endpoint?url=https://dashboard.cypress.io/badge/simple/ke77ns/prod-current&style=flat&logo=cypress)](https://dashboard.cypress.io/projects/ke77ns/analytics/runs-over-time) | [Pipelines da Azure](https://dev.azure.com/freeCodeCamp-org/freeCodeCamp/_dashboards/dashboard/d59f36b9-434a-482d-8dbd-d006b71713d4) |
| `prod-next` (experimental, ainda está por vir) | - | - | - |
## Early access and beta testing
## Acesso antecipado e teste beta
Você é bem-vindo para testar estes lançamentos em um modo **de "beta testing público"** e obter acesso antecipado às funcionalidades que estão por vir. Às vezes, esses recursos/mudanças são referidos como **next, beta, staging,** etc. interligadamente.
@ -173,7 +173,7 @@ Suas contribuições por meio de comentários e issues nos ajudarão a fazer as
Agradecemos por relatar erros que encontra e ajuda para melhorar o freeCodeCamp.org. Você é demais!
### Identifying the upcoming version of the platforms
### Identificando a próxima versão das plataformas
Atualmente uma versão pública de testes beta está disponível em:
@ -191,33 +191,33 @@ Atualmente uma versão pública de testes beta está disponível em:
>
> A lista (não muito longa) abaixo contém todos os aplicativos que fornecemos. Nem todas as variantes das linguagens são implantadas na fase de preparação para conservar recursos.
### Identifying the current version of the platforms
### Identificando a versão atual das plataformas
**The current version of the platform is always available at [`freeCodeCamp.org`](https://www.freecodecamp.org).**
**A versão atual da plataforma está sempre disponível em [`freeCodeCamp.org`](https://www.freecodecamp.org).**
O time de desenvolvimento faz o merge nas mudanças da branch `prod-staging` para `prod-current` quando lançam mudanças. O commit principal deve ser o que você vê no site.
Você pode identificar a versão exata implantada visitando os registros de compilação e implantação disponíveis na seção de estado. Alternativamente, você também pode entrar em contato na [sala de bate-papo dos contribuidores](https://chat.freecodecamp.org/channel/contributors).
### Known Limitations
### Limitações conhecidas
Existem algumas limitações e desvantagens conhecidas ao usar a versão beta da plataforma.
- #### All data / personal progress on these beta platforms `will NOT be saved or carried over` to production.
- #### Todos os dados/progresso pessoal nessas plataformas beta NÃO serão salvos ou transferidos para a produção.
**Users on the beta version will have a separate account from the production.** The beta version uses a physically separate database from production. This gives us the ability to prevent any accidental loss of data or modifications. The dev team may purge the database on this beta version as needed.
**Os usuários na versão beta terão uma conta separada da produção.** A versão beta usa um banco de dados fisicamente separado da produção. Isso nos dá a capacidade de evitar qualquer perda acidental de dados ou modificações. A equipe de desenvolvimento pode limpar o banco de dados nesta versão beta conforme necessário.
- #### Não há garantias na disponibilidade e confiabilidade das plataformas beta.
Deployment is expected to be frequent and in rapid iterations, sometimes multiple times a day. As a result there will be unexpected downtime at times or broken functionality on the beta version.
Espera-se que a implantação seja frequente e em iterações rápidas, às vezes várias vezes ao dia. Como resultado, haverá tempos de inatividade inesperados ou funcionalidades quebradas na versão beta.
- #### Não envie usuários regulares para este site como uma medida de confirmar uma correção
The beta site is and always has been to augment local development and testing, nothing else. It's not a promise of what’s coming, but a glimpse of what is being worked upon.
O site beta é e sempre foi para melhorar o desenvolvimento e os testes locais, nada mais. Não é uma promessa do que está por vir, mas um vislumbre do que está sendo trabalhado.
- #### Sign in page may look different than production
- #### O login na página pode parecer diferente da produção
Nós utilizamos um locatário de teste para o freeCodeCamp.dev no Auth 0 e, portanto, não temos a capacidade de definir um domínio personalizado. This makes it so that all the redirect callbacks and the login page appear at a default domain like: `https://freecodecamp-dev.auth0.com/`. Isso não afeta a funcionalidade e é o mais próximo da produção que conseguimos.
Nós utilizamos um locatário de teste para o freeCodeCamp.dev no Auth 0 e, portanto, não temos a capacidade de definir um domínio personalizado. Isso faz com que todas as callbacks de redirecionamento e a página de login apareçam em um domínio padrão como: `https://freecodecamp-dev.auth0.com/`. Isso não afeta a funcionalidade e é o mais próximo da produção que conseguimos.
## Relatar problemas e deixar comentário
@ -232,7 +232,7 @@ Você pode enviar um e-mail para `dev[at]freecodecamp.org` se você tiver alguma
> 1. O guia se aplica aos **membros da equipe freeCodeCamp apenas**.
> 2. Não se deve considerar que essas instruções cubram todas as possibilidades. Tenha cuidado.
As a member of the staff, you may have been given access to our cloud service providers like Azure, Digital Ocean, etc.
Como membro da equipe, você pode ter acesso aos nossos provedores de serviços em nuvem, como Azure, Digital Ocean, etc.
Aqui estão alguns comandos úteis que você pode usar ao trabalhar com máquinas virtuais (VM), por exemplo, realizando atualizações de manutenção ou limpezas em geral.
@ -266,15 +266,15 @@ az vm list-ip-addresses --output table
Instale Digital Ocean CLI `doctl`: https://github.com/digitalocean/doctl#installing-doctl
> **(One-time) Install on macOS with [`homebrew`](https://brew.sh):**
> **(Apenas uma vez) Instale no macOS com [`homebrew`](https://brew.sh):**
```
brew install doctl
```
> **(One-time) Login:**
> **(Apenas uma vez) Login:**
Authentication and context switching: https://github.com/digitalocean/doctl#authenticating-with-digitalocean
Autenticação e troca de contexto: https://github.com/digitalocean/doctl#authenticating-with-digitalocean
```
doctl auth init
@ -292,9 +292,9 @@ Nós estamos trabalhando na criação da configuração do IaC. Enquanto isso es
> [!TIP] Não importa sua escolha de como gastar os recursos, nós temos alguns [arquivos de configuração úteis cloud-init](https://github.com/freeCodeCamp/infra/tree/main/cloud-init) para ajudar você a fazer provisionamento básico de como instalar o docker ou adicionar chaves SSH, etc.
## Keep VMs updated
## Mantenha as VMs atualizadas
You should keep the VMs up to date by performing updates and upgrades. Isto vai garantir que a máquina virtual está corrigida com correções de segurança mais recentes.
Você deve manter as VMs atualizadas realizando atualizações e atualizações. Isto vai garantir que a máquina virtual está corrigida com correções de segurança mais recentes.
> [!WARNING] Antes de executar estes comandos:
>
@ -323,11 +323,11 @@ sudo apt autoremove -y
Estamos executando instâncias equilibradas (Azure Load Balancer) para nossos servidores na web. Esses servidores estão executando NGINX, que reverte o proxy de todo o tráfego para freeCodeCamp.org a partir de várias aplicações em execução em suas próprias infraestruturas.
The NGINX config is available on [this repository](https://github.com/freeCodeCamp/nginx-config).
A configuração do NGINX está disponível neste [repositório](https://github.com/freeCodeCamp/nginx-config).
### Primeiro instale
Provisioning VMs with the Code
Provisionando VMs com o código
1. Instale o NGINX e configure a partir do repositório.
@ -376,31 +376,31 @@ Provisioning VMs with the Code
4. Adicione a MV ao pool de back-end do balanceador de carga.
Configure e adicione as regras ao balanceador de carga, se necessário. You may also need to add the VMs to load balancer backend pool if needed.
Configure e adicione as regras ao balanceador de carga, se necessário. Você também pode precisar adicionar as MVs ao pool do balanceador de cargas, se necessário.
### Logging and Monitoring
### Registro e monitoramento
1. Check status for NGINX service using the below command:
1. Verifique o estado do serviço NGINX usando o comando abaixo:
```console
sudo systemctl status nginx
```
2. Logging and monitoring for the servers are available at:
2. Registro e monitoramento para os servidores estão disponíveis em:
NGINX Amplify: [https://amplify.nginx.com]('https://amplify.nginx.com'), our current basic monitoring dashboard. We are working on more granular metrics for better observability
NGINX Amplify: [https://amplify.nginx.com]('https://amplify.nginx.com'), nosso painel básico para monitoração atual. Estamos melhorando as observações com mais métricas granulares
### Updating Instances (Maintenance)
### Atualizando instâncias (Manutenção)
Config changes to our NGINX instances are maintained on GitHub, these should be deployed on each instance like so:
Configure as mudanças das instâncias do NGINX que são mantidas no GitHub, estas devem ser implantadas em cada instância assim:
1. SSH into the instance and enter sudo
1. SSH na instância e digite sudo
```console
sudo su
```
2. Get the latest config code.
2. Obtenha o código de configuração mais recente.
```console
cd /etc/nginx
@ -408,28 +408,28 @@ git fetch --all --prune
git reset --hard origin/main
```
3. Test and reload the config [with Signals](https://docs.nginx.com/nginx/admin-guide/basic-functionality/runtime-control/#controlling-nginx).
3. Teste e recarregue a configuração [com Signals](https://docs.nginx.com/nginx/admin-guide/basic-functionality/runtime-control/#controlling-nginx).
```console
nginx -t
nginx -s reload
```
## Work on API Instances
## Trabalhe nas instâncias de API
1. Install build tools for node binaries (`node-gyp`) etc.
1. Instale ferramentas de compilação para binários node (`node-gyp`), etc.
```console
sudo apt install build-essential
```
### First Install
### Primeira instalação
Provisioning VMs with the Code
Provisionando MVs com o código
1. Install Node LTS.
1. Instale Node LTS.
2. Update `npm` and install PM2 and setup `logrotate` and startup on boot
2. Atualize o `npm` instale o PM2 e a configuração `logrotate` e inicie no boot
```console
npm i -g npm@6
@ -438,7 +438,7 @@ Provisioning VMs with the Code
pm2 startup
```
3. Clone freeCodeCamp, setup env and keys.
3. Clone freeCodeCamp, configuração env e chaves.
```console
git clone https://github.com/freeCodeCamp/freeCodeCamp.git
@ -446,30 +446,30 @@ Provisioning VMs with the Code
git checkout prod-current # or any other branch to be deployed
```
4. Create the `.env` from the secure credentials storage.
4. Crie o `.env` a partir do armazenamento seguro de credenciais.
5. Create the `google-credentials.json` from the secure credentials storage.
5. Crie o `google-credentials.json` a partir do armazenamento seguro de credenciais.
6. Install dependencies
6. Instale dependências
```console
npm ci
```
7. Build the server
7. Compile o servidor
```console
npm run ensure-env && npm run build:curriculum && npm run build:server
```
8. Start Instances
8. Inicie instâncias
```console
cd api-server
pm2 start ./lib/production-start.js -i max --max-memory-restart 600M --name org
```
### Logging and Monitoring
### Registro e monitoramento
```console
pm2 logs
@ -479,61 +479,61 @@ pm2 logs
pm2 monit
```
### Updating Instances (Maintenance)
### Atualizando instâncias (Manutenção)
Code changes need to be deployed to the API instances from time to time. It can be a rolling update or a manual update. The later is essential when changing dependencies or adding environment variables.
Mudanças no código devem ser implementadas na instância da API de tempos em tempos. Pode ser uma atualização contínua ou manual. A data posterior é essencial quando estão sendo realizadas mudanças ou adições variáveis de ambiente.
> [!ATTENTION] The automated pipelines are not handling dependencies updates at the minute. We need to do a manual update before any deployment pipeline runs.
> [!ATTENTION] Os pipelines automatizados não estão manipulando atualizações de dependências no momento. É necessário fazer uma atualização manual antes que qualquer desenvolvimento nas pipelines seja executado.
#### 1. Manual Updates - Used for updating dependencies, env variables.
#### 1. Atualizações manuais - Usado para atualizar dependências, variáveis de ambiente.
1. Stop all instances
1. Pare todas as instâncias
```console
pm2 stop all
```
2. Install dependencies
2. Instale dependências
```console
npm ci
```
3. Build the server
3. Compile o servidor
```console
npm run ensure-env && npm run build:curriculum && npm run build:server
```
4. Start Instances
4. Inicie instâncias
```console
pm2 start all --update-env && pm2 logs
```
#### 2. Rolling updates - Used for logical changes to code.
#### 2. Atualizações contínuas - Usado par mudanças lógicas no código.
```console
pm2 reload all --update-env && pm2 logs
```
> [!NOTE] We are handling rolling updates to code, logic, via pipelines. You should not need to run these commands. These are here for documentation.
> [!NOTE] Nós estamos lidando com atualizações contínuas no código, lógico, via pipelines. Você não deve executar estes comandos. Eles estão aqui para a documentação.
## Work on Client Instances
## Trabalhe em instâncias de cliente
1. Install build tools for node binaries (`node-gyp`) etc.
1. Instale ferramentas de compilação para binários node (`node-gyp`), etc.
```console
sudo apt install build-essential
```
### First Install
### Primeira instalação
Provisioning VMs with the Code
Provisionando MVs com o código
1. Install Node LTS.
1. Instale Node LTS.
2. Update `npm` and install PM2 and setup `logrotate` and startup on boot
2. Atualize o `npm` e instale o PM2 e configure `logrotate` e inicie quando reiniciar
```console
npm i -g npm@6
@ -543,16 +543,16 @@ Provisioning VMs with the Code
pm2 startup
```
3. Clone client config, setup env and keys.
3. Clone a configuração de cliente, env e chaves.
```console
git clone https://github.com/freeCodeCamp/client-config.git client
cd client
```
Start placeholder instances for the web client, these will be updated with artifacts from the Azure pipeline.
Inicie instâncias placeholder para o cliente web, elas serão atualizadas com artefatos do Azure pipeline.
> Todo: This setup needs to move to S3 or Azure Blob storage
> A fazer: Esta configuração precisa ser movida para S3 ou armazenamento Azure Blob
>
> ```console
> echo "serve -c ../../serve.json www -p 50505" >> client-start-primary.sh
@ -565,7 +565,7 @@ Provisioning VMs with the Code
> pm2 start ./client-start-secondary.sh --name client-secondary
> ```
### Logging and Monitoring
### Registro e Monitoramento
```console
pm2 logs
@ -575,49 +575,49 @@ pm2 logs
pm2 monit
```
### Updating Instances (Maintenance)
### Atualizando instâncias (Manutenção)
Code changes need to be deployed to the API instances from time to time. It can be a rolling update or a manual update. The later is essential when changing dependencies or adding environment variables.
As alterações no código precisam ser implementadas para as instâncias de API de vez em quando. Pode ser uma atualização contínua ou manual. A data posterior é essencial quando estão sendo realizadas mudanças ou adições variáveis de ambiente.
> [!ATTENTION] The automated pipelines are not handling dependencies updates at the minute. We need to do a manual update before any deployment pipeline runs.
> [!ATTENTION] Os pipelines automatizados não estão manipulando atualizações de dependências no momento. É necessário fazer uma atualização manual antes que qualquer deploy nas pipelines seja executado.
#### 1. Manual Updates - Used for updating dependencies, env variables.
#### 1. Atualizações manuais - Usadas para atualizar dependências, variáveis de ambiente.
1. Stop all instances
1. Pare todas as instâncias
```console
pm2 stop all
```
2. Install or update dependencies
2. Instale ou atualize dependências
3. Start Instances
3. Inicie instâncias
```console
pm2 start all --update-env && pm2 logs
```
#### 2. Rolling updates - Used for logical changes to code.
#### 2. Atualizações contínuas - Usadas para mudanças lógicas no código.
```console
pm2 reload all --update-env && pm2 logs
```
> [!NOTE] We are handling rolling updates to code, logic, via pipelines. You should not need to run these commands. These are here for documentation.
> [!NOTE] Nós estamos lidando com atualizações contínuas no código, lógico, via pipelines. Você não deve ter a necessidade de executar esses comandos. Eles estão aqui para documentação.
## Work on Chat Servers
## Trabalhando nos servidores do chat
Our chat servers are available with a HA configuration [recommended in Rocket.Chat docs](https://docs.rocket.chat/installation/docker-containers/high-availability-install). The `docker-compose` file for this is [available here](https://github.com/freeCodeCamp/chat-config).
Nossos servidores de chat estão disponíveis com uma configuração HA [recomendada na documentação Rocket.Chat](https://docs.rocket.chat/installation/docker-containers/high-availability-install). O arquivo `docker-compose` para isso está [disponível aqui](https://github.com/freeCodeCamp/chat-config).
We provision redundant NGINX instances which are themselves load balanced (Azure Load Balancer) in front of the Rocket.Chat cluster. The NGINX configuration file are [available here](https://github.com/freeCodeCamp/chat-nginx-config).
Fornecemos instâncias NGINX redundantes com balanceamento de carga (Azure Load Balancer) na frente do cluster Rocket.Chat. O arquivo de configuração NGINX está [disponível aqui](https://github.com/freeCodeCamp/chat-nginx-config).
### First Install
### Primeira instalação
Provisioning VMs with the Code
Provisionando MVs com código
**NGINX Cluster:**
**Cluster do NGINX:**
1. Install NGINX and configure from repository.
1. Instale o NGINX e configure a partir do repositório.
```console
sudo su
@ -632,85 +632,85 @@ Provisioning VMs with the Code
cd /etc/nginx
```
2. Install Cloudflare origin certificates and upstream application config.
2. Instale os certificados de origem Cloudflare e a configuração de aplicativos upstream.
Get the Cloudflare origin certificates from the secure storage and install at required locations.
Obtenha os certificados de origem Cloudflare a partir do armazenamento seguro e instale nos locais requiridos.
**OR**
**OU**
Move over existing certificates:
Mova os certificados existentes:
```console
# Local
# Localmente
scp -r username@source-server-public-ip:/etc/nginx/ssl ./
scp -pr ./ssl username@target-server-public-ip:/tmp/
# Remote
# Remotamente
rm -rf ./ssl
mv /tmp/ssl ./
```
Update Upstream Configurations:
Atualize as configurações Upstream:
```console
vi configs/upstreams.conf
```
Add/update the source/origin application IP addresses.
Adicione/atualize os endereços IP do aplicativo fonte/origem.
3. Setup networking and firewalls.
3. Configure a rede e o firewall.
Configure Azure firewalls and `ufw` as needed for ingress origin addresses.
Configure o firewall da Azure e `ufw` conforme necessário para entrar os endereços de origem.
4. Add the VM to the load balancer backend pool.
4. Adicione a MV ao pool de back-end do balanceador de carga.
Configure and add rules to load balancer if needed. You may also need to add the VMs to load balancer backend pool if needed.
Configure e adicione as regras ao balanceador de carga, se necessário. Você também pode precisar adicionar as MVs ao pool do balanceador de cargas, se necessário.
**Docker Cluster:**
**Cluster do Docker:**
1. Install Docker and configure from the repository
1. Instale o Docker e configure a partir do repositório
```console
git clone https://github.com/freeCodeCamp/chat-config.git chat
cd chat
```
2. Configure the required environment variables and instance IP addresses.
2. Configure as variáveis de ambiente necessárias e as instâncias dos endereços de IP.
3. Run rocket-chat server
3. Execute rocket-chat server
```console
docker-compose config
docker-compose up -d
```
### Logging and Monitoring
### Registro e monitoramento
1. Check status for NGINX service using the below command:
1. Verifique o estado do serviço NGINX usando o comando abaixo:
```console
sudo systemctl status nginx
```
2. Check status for running docker instances with:
2. Verifique o estado das instâncias do Docker que estão sendo executadas com:
```console
docker ps
```
### Updating Instances (Maintenance)
### Atualizando instâncias (Manutenção)
**NGINX Cluster:**
**Cluster do NGINX:**
Config changes to our NGINX instances are maintained on GitHub, these should be deployed on each instance like so:
As alterações na configuração das nossas instâncias NGINX são mantidas no GitHub, elas devem ser implantadas em cada instância assim:
1. SSH into the instance and enter sudo
1. SSH na instância e digite sudo
```console
sudo su
```
2. Get the latest config code.
2. Obtenha o código de configuração mais recente.
```console
cd /etc/nginx
@ -718,70 +718,70 @@ Config changes to our NGINX instances are maintained on GitHub, these should be
git reset --hard origin/main
```
3. Test and reload the config [with Signals](https://docs.nginx.com/nginx/admin-guide/basic-functionality/runtime-control/#controlling-nginx).
3. Teste e recarregue a configuração [com Signals](https://docs.nginx.com/nginx/admin-guide/basic-functionality/runtime-control/#controlling-nginx).
```console
nginx -t
nginx -s reload
```
**Docker Cluster:**
**Cluster do Docker:**
1. SSH into the instance and navigate to the chat config path
1. SSH na instância e vá para onde está o arquivo de configuração do chat
```console
cd ~/chat
```
2. Get the latest config code.
2. Obtenha o código de configuração mais recente.
```console
git fetch --all --prune
git reset --hard origin/main
```
3. Pull down the latest docker image for Rocket.Chat
3. Obtenha a imagem docker mais recente do Rocket.Chat
```console
docker-compose pull
```
4. Update the running instances
4. Atualize as instâncias que estão executando
```console
docker-compose up -d
```
5. Validate the instances are up
5. Veja se as instâncias estão executando
```console
docker ps
```
6. Cleanup extraneous resources
6. Limpe recursos estranhos
```console
docker system prune --volumes
```
Output:
Resultado:
```console
WARNING! This will remove:
- all stopped containers
- all networks not used by at least one container
- all volumes not used by at least one container
- all dangling images
- all dangling build cache
AVISO! Isso removerá
- todos os containers parados
- todas as redes que não estão sendo usadas por pelo menos um container
- todos os volumes que não estão sendo usados por pelo menos um container
- todas as imagens pendentes
- todos os caches de compilação pendentes
Are you sure you want to continue? [y/N] y
Tem certeza que deseja continuar? [y/N] y
```
Select yes (y) to remove everything that is not in use. This will remove all stopped containers, all networks and volumes not used by at least one container, and all dangling images and build caches.
Selecione sim (y) para remover tudo que não está sendo usado. Isso vai remover todos os containers parados, todas as redes e volumes não usados por pelo menos um container e imagens pendentes e caches de compilação.
## Updating Node.js versions on VMs
## Atualize as versões do Node.js nas MVs
List currently installed node & npm versions
Liste as versões do node e do npm instaladas
```console
nvm -v
@ -791,33 +791,33 @@ npm -v
nvm ls
```
Install the latest Node.js LTS, and reinstall any global packages
Instale a versão LTS Node.js mais recente e reinstale qualquer pacote global
```console
nvm install 'lts/*' --reinstall-packages-from=default
```
Verify installed packages
Verifique os pacotes instalados
```console
npm ls -g --depth=0
```
Alias the `default` Node.js version to the current LTS
Crie um alias da versão `default` do Node.js para a versão current LTS
```console
nvm alias default lts/*
```
(Optional) Uninstall old versions
(Opcional) Desinstale versões antigas
```console
nvm uninstall <version>
```
> [!WARNING] If using PM2 for processes you would also need to bring up the applications and save the process list for automatic recovery on restarts.
> [!WARNING] Se estiver usando PM2 para os processos você também vai precisar executar as aplicações e salvar a lista de processos para restaurações automáticas quando reiniciar.
Quick commands for PM2 to list, resurrect saved processes, etc.
Comandos rápidos PM2 para listar, reviver processos salvos, etc.
```console
pm2 ls
@ -835,85 +835,85 @@ pm2 save
pm2 logs
```
> [!ATTENTION] For client applications, the shell script can't be resurrected between Node.js versions with `pm2 resurrect`. Deploy processes from scratch instead. This should become nicer when we move to a docker based setup.
> [!ATTENTION] Para aplicações de client, o script de shell não pode ser revivido entre as versões do Node.js com `pm2 resurrect`. Implante processos de zero ao invés disso. Isso deve melhorar quando mudarmos para uma configuração baseada em docker.
## Installing and Updating Azure Pipeline Agents
## Instalando e atualizando agentes do Azure Pipeline
See: https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/v2-linux?view=azure-devops and follow the instructions to stop, remove and reinstall agents. Broadly you can follow the steps listed here.
Veja: https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/v2-linux?view=azure-devops e siga as instruções para parar, remover e reinstalar os agentes. Em resumo, você pode seguir as etapas listadas aqui.
You would need a PAT, that you can grab from here: https://dev.azure.com/freeCodeCamp-org/_usersSettings/tokens
Você vai precisar de um PAT, que você pode pegar nesse link: https://dev.azure.com/freeCodeCamp-org/_usersSettings/tokens
### Installing agents on Deployment targets
### Instalando agentes em alvos de implantação
Navigate to [Azure Devops](https://dev.azure.com/freeCodeCamp-org) and register the agent from scratch in the requisite [deployment groups](https://dev.azure.com/freeCodeCamp-org/freeCodeCamp/_machinegroup).
Vá para [Azure Devops](https://dev.azure.com/freeCodeCamp-org) e registre o agente do zero nos [grupos de implantação](https://dev.azure.com/freeCodeCamp-org/freeCodeCamp/_machinegroup) necessários.
> [!NOTE] You should run the scripts in the home directory, and make sure no other `azagent` directory exists.
> [!NOTE] Você deve executar os scripts no diretório principal e ter certeza de que nenhum outro diretório `azagent` existe.
### Updating agents
### Atualizando agentes
Currently updating agents requires them to be removed and reconfigured. This is required for them to correctly pick up `PATH` values and other system environment variables. We need to do this for instance updating Node.js on our deployment target VMs.
Atualmente, atualizar os agentes requer que sejam removidos e reconfigurados. Isso é necessário para que eles tenham os valores do `PATH` e de outras variáveis de ambiente corretos. Precisamos fazer isso, por exemplo, para atualizar Node.js em nossas MVs de implantação.
1. Navigate and check status of the service
1. Vá e verifique o estado do serviço
```console
cd ~/azagent
sudo ./svc.sh status
```
2. Stop the service
2. Pare o serviço
```console
sudo ./svc.sh stop
```
3. Uninstall the service
3. Desinstale o serviço
```console
sudo ./svc.sh uninstall
```
4. Remove the agent from the pipeline pool
4. Remova o agente da piscina pipeline
```console
./config.sh remove
```
5. Remove the config files
5. Remova os arquivos de configuração
```console
cd ~
rm -rf ~/azagent
```
Once You have completed the steps above, you can repeat the same steps as installing the agent.
Uma vez que você completar as etapas acima, você pode repetir as mesmas etapas na instalação do agente.
# Flight Manual - Email Blast
# Manual de Vôo - Disparo de e-mail
We use [a CLI tool](https://github.com/freecodecamp/sendgrid-email-blast) to send out the weekly newsletter. To spin this up and begin the process:
Nós usamos [uma ferramenta de linha de comando](https://github.com/freecodecamp/sendgrid-email-blast) para enviar a newsletter semanal. Para começar o processo:
1. Sign in to DigitalOcean, and spin up new droplets under the `Sendgrid` project. Use the Ubuntu Sendgrid snapshot with the most recent date. This comes pre-loaded with the CLI tool and the script to fetch emails from the database. With the current volume, three droplets are sufficient to send the emails in a timely manner.
1. Se inscreva na DigitalOcean, e inicie o use de novas droplets sob o projeto `Sendgrid`. Use uma snapshot da Sendgrid no Ubuntu com a data mais recente. Isso vem pré-instalado com a ferramenta da linha de comando para pegar e-mails da base de dados. Com o volume atual, três droplets são suficientes para enviar emails de forma oportuna.
2. Set up the script to fetch the email list.
2. Configure o script para pegar a lista de email.
```console
cd /home/freecodecamp/scripts/emails
cp sample.env .env
```
You will need to replace the placeholder values in the `.env` file with your credentials.
Você vai precisar substituir os valores padrão dentro do arquivo `.env` com suas credenciais.
3. Run the script.
3. Rode o script.
```console
node get-emails.js emails.csv
```
This will save the email list in an `emails.csv` file.
Isso vai salvar a lista de email em um arquivo `emails.csv`.
4. Break the emails down into multiple files, depending on the number of droplets you need. This is easiest to do by using `scp` to pull the email list locally and using your preferred text editor to split them into multiple files. Each file will need the `email,unsubscribeId` header.
4. Divida os e-mails em vários arquivos, dependendo do número de droplets que você precisa. Isso fica mais fácil usando `scp` para baixar a lista de e-mails localmente e usar seu editor de texto favorito para dividi-los em múltiplos arquivos. Cada arquivo precisará do cabeçalho `email,unsubscribeId`.
5. Switch to the CLI directory with `cd /home/sendgrid-email-blast` and configure the tool [per the documentation](https://github.com/freeCodeCamp/sendgrid-email-blast/blob/main/README.md).
5. Mude para o diretório CLI com `cd /home/sendgrid-email-blast` e configure a ferramenta [conforme a documentação](https://github.com/freeCodeCamp/sendgrid-email-blast/blob/main/README.md).
6. Run the tool to send the emails, following the [usage documentation](https://github.com/freeCodeCamp/sendgrid-email-blast/blob/main/docs/cli-steps.md).
6. Execute a ferramenta para enviar os e-mails, seguindo a [documentação](https://github.com/freeCodeCamp/sendgrid-email-blast/blob/main/docs/cli-steps.md).
7. When the email blast is complete, verify that no emails have failed before destroying the droplets.
7. Quando o disparo de email estiver completo, verifique se nenhum e-mail falhou antes de destruir os droplets.

56
docs/i18n/portuguese/how-to-add-cypress-tests.md
View File

@ -1,83 +1,83 @@
# How to add Cypress tests
# Como adicionar testes Cypress
When making changes to JavaScript, CSS, or HTML which could change the functionality or layout of a page, it's important to add corresponding [Cypress](https://docs.cypress.io) integration tests.
Quando estiver realizando alterações em JavaScript, CSS ou HTML que podem mudar a funcionalidade ou aparência de uma página, é importante incluir os testes de integração [Cypress](https://docs.cypress.io) correspondentes.
To learn how to write Cypress tests, or 'specs', please see Cypress' official [documentation](https://docs.cypress.io/guides/getting-started/writing-your-first-test.html).
Para aprender como escrever testes Cypress ou 'specs', por favor confira a [documentação](https://docs.cypress.io/guides/getting-started/writing-your-first-test.html) oficial do Cypress.
> Note: When writing tests for freeCodeCamp, remember to add `/* global cy */` to the top of the file to avoid ESLint issues.
> Nota: Quando estiver escrevendo testes para o freeCodeCamp, lembre-se de adicionar `/* global cy */` ao topo do arquivo para evitar complicações com ESLint.
## Where to add a test
## Onde adicionar um teste
- Cypress tests are in the `./cypress` directory.
- Testes Cypress estão no diretório `./cypress`.
- Cypress tests for a curriculum module are in the corresponding curriculum directory, i.e. `cypress/integration/learn/responsive-web-design/basic-css/index.js`.
- Testes do Cypress para um módulo do currículo estão no diretório do currículo correspondente, ou seja, `cypress/integration/learn/responsive-web-design/basic-css/index.js`.
## How to run tests
## Como executar testes
> [!NOTE] If using GitPod, please see [Cypress-GitPod Setup](/how-to-add-cypress-tests#cypress-gitpod-setup)
> [!NOTE] Se estiver usando GitPod, por favor veja essa [configuração sobre Cypress-GitPod](/how-to-add-cypress-tests#cypress-gitpod-setup)
### 1. Ensure that MongoDB and client applications are running
### 1. Veja se as aplicações de cliente e MongoDB estão executando
- [Start MongoDB and seed the database](/how-to-setup-freecodecamp-locally#step-3-start-mongodb-and-seed-the-database)
- [Inicie o MongoDB e crie o banco de dados](/how-to-setup-freecodecamp-locally#step-3-start-mongodb-and-seed-the-database)
- [Start the freeCodeCamp client application and API server](/how-to-setup-freecodecamp-locally#step-4-start-the-freecodecamp-client-application-and-api-server)
- [Inicie também a aplicação de cliente freeCodeCamp e o servidor API](/how-to-setup-freecodecamp-locally#step-4-start-the-freecodecamp-client-application-and-api-server)
### 2. Run the cypress tests
### 2. Execute os testes do Cypress
To run tests against production builds, replace `dev` with `prd` below.
Para executar testes usando compilações de produção, substitua `dev` por `prd` abaixo.
- To run all tests in the `./cypress` directory:
- Para executar todos os testes no diretório `./cypress`:
```console
npm run cypress:dev:run
```
- To run a single test:
- Para executar um único teste:
```console
npm run cypress:dev:run -- --spec=cypress/pathToYourSpec/youSpecFileName.js
```
- To create a development build, start the development server, and run all existing cypress end-to-end tests:
- Para criar uma versão de compilação, inicie o servidor de desenvolvimento e execute todos os testes cypress contínuos e funcionais existentes:
```console
npm run e2e:dev:run
```
## Cypress-GitPod Setup
## Configuração do Cypress-GitPod
### 1. Ensure you are on the _Feature Preview_ of GitPod _as of 01/02/2021_
### 1. Certifique-se de estar na _Feature Preview_ do GitPod _a partir de 02/01/2021_
- Go to [GitPod Docs - Feature Preview](https://www.gitpod.io/docs/feature-preview/) to see how to enable _Feature Preview_
- Visite [GitPod Docs - Feature Preview](https://www.gitpod.io/docs/feature-preview/) para ver como ativar a _Feature Preview_
### 2. Ensure Development Environment is Running
### 2. Certifique-se que o ambiente de desenvolvimento está em execução
If starting the GitPod environment did not automatically develop the environment:
Se o ambiente GitPod não foi criado automaticamente:
- Start the database
- Inicie a base de dados
```console
mongod
```
- Seed the database
- Crie a base de dados
```console
npm run seed
```
- Develop the server and client
- Desenvolva o servidor e o cliente
```console
npm run develop
```
### 3. Install Cypress Build Tools
### 3. Instale ferramentas de compilação do Cypress
```console
npm run cypress:install-build-tools
```
- When prompted in the terminal, select your keyboard layout by language/area
- Quando solicitado no terminal, selecione o layout do seu teclado por idioma/área
Now, [Cypress can be run](/how-to-add-cypress-tests#_2-run-the-cypress-tests)
Agora, [Cypress pode ser executado](/how-to-add-cypress-tests#_2-run-the-cypress-tests)

36
docs/i18n/portuguese/how-to-help-with-video-challenges.md
View File

@ -1,15 +1,15 @@
# Como ajudar com desafios em vídeo
Video challenges are a new type of challenge in the freeCodeCamp curriculum.
Os desafios em vídeo são um novo tipo de desafio no currículo freeCodeCamp.
Um desafio em vídeo é uma seção de um curso completo sobre um determinado tópico. Uma página de desafio em vídeo incorpora um vídeo do YouTube. Each challenge page has a single multiple-choice question related to the video. O usuário deve responder a pergunta corretamente antes de avançar para o próximo desafio em vídeo.
Um desafio em vídeo é uma seção de um curso completo sobre um determinado tópico. Uma página de desafio em vídeo incorpora um vídeo do YouTube. Cada página de desafio tem uma única pergunta de múltipla escolha relacionada ao vídeo. O usuário deve responder a pergunta corretamente antes de avançar para o próximo desafio em vídeo.
As páginas de desafio em vídeo são criadas por membros da equipe freeCodeCamp. YouTube videos are also uploaded by members of the freeCodeCamp team. Muitos dos desafios em vídeo ainda não possuem perguntas associadas a eles.
As páginas de desafio em vídeo são criadas por membros da equipe freeCodeCamp. Vídeos do YouTube também são enviados por membros da equipe freeCodeCamp. Muitos dos desafios em vídeo ainda não possuem perguntas associadas a eles.
You can help by creating multiple-choice questions related to video sections and adding the questions to the markdown files for the video challenges.
Você pode ajudar criando questões de múltipla escolha e adicionando-as aos arquivos 'markdown' para os desafios em vídeo.
## Challenge Template
## Modelo de desafio
Abaixo está um modelo de arquivo markdown do desafio.
@ -34,27 +34,27 @@ Challenge description text, in markdown
# --question--
These fields are currently used for the multiple-choice Python challenges.
Esses espaços são normalmente utilizados para questões de múltipla escolha dos desafios de Python.
## --text--
The question text goes here.
O texto da questão vêm aqui.
## --answers--
Answer 1
Resposta 1
---
Answer 2
Resposta 2
---
More answers
Mais respostas
## --video-solution--
The number for the correct answer goes here.
O número da resposta correta fica aqui.
````
@ -75,7 +75,7 @@ Escolha um arquivo dentre as opções acima.
Primeiro, localize o videoId.
For example, in the following code from the header of a video challenge markdown file, the videoId is "nVAaxZ34khk". No GitHub, a informação deve estar contida em formato tabular.
Por exemplo, no código a seguir a partir do cabeçalho de um arquivo markdown de desafio de vídeo, o videoId é "nVAaxZ34khk". No GitHub, a informação deve estar contida em formato tabular.
````
---
id: 5e9a093a74c4063ca6f7c14d title: Data Analysis Example A challengeType: 11
@ -83,16 +83,16 @@ videoId: nVAaxZ34khk
---
```
Em seguida, acesse o vídeo no YouTube correspondente com aquele `videoId`. The URL for the video will be:
https://www.youtube.com/watch?v=[videoId] (replace `videoId` in the URL with the video's ID - without square brackets)
Em seguida, acesse o vídeo no YouTube correspondente com aquele `videoId`. A URL do vídeo será:
https://www.youtube.com/watch?v=[videoId] (troque `videoId` na URL pelo ID do vídeo - sem colchetes)
In the example above, the URL is https://www.youtube.com/watch?v=nVAaxZ34khk
No exemplo acima, a URL seria https://www.youtube.com/watch?v=nVAaxZ34khk
Skim the YouTube video with that videoId and think of a multiple-choice question based on the content of the video.
Assista ao vídeo no YouTube daquele videoId e pense em uma questão de múltipla escolha baseada em seu conteúdo.
### Adicione a pergunta ao arquivo markdown
Você pode adicionar a pergunta localmente ou utilizando a interface do Github. Para adicionar a pergunta localmente, você precisa [configurar o freeCodeCamp localmente](how-to-setup-freecodecamp-locally.md). You can also find the file on GitHub and click the edit button to add the question right in your browser.
Você pode adicionar a pergunta localmente ou utilizando a interface do Github. Para adicionar a pergunta localmente, você precisa [configurar o freeCodeCamp localmente](how-to-setup-freecodecamp-locally.md). Você também pode encontrar o arquivo no GitHub e clicar no botão editar para adicionar a pergunta diretamente em seu navegador.
Se uma pergunta não tiver sido adicionada a um desafio de vídeo ainda, ela terá a seguinte forma padrão:
@ -126,7 +126,7 @@ Adicione/atualize o texto da pergunta sob a parte que diz:
## --text--
```
Add/Update answers (`Answer 1`, `Answer 2`, and so on) under `## --answers--`. Make sure to update the number under `## --video-solution--` with the correct answer number. You can add more possible answers using the same format. The question and answers can be surrounded with quotation marks.
Adicione/Atualize (`Resposta 1`, `Resposta 2`, e assim por diante) sob `## --answers--`. Confirme se o número sob `## --video-solution--` seja o número da resposta correta. Você pode adicionar mais respostas possíveis usando o mesmo formato. Tanto a pergunta quanto as respostas podem estar entre aspas.
### Exemplos de perguntas

38
docs/i18n/portuguese/how-to-open-a-pull-request.md
View File

@ -1,4 +1,4 @@
# How to open a Pull Request (PR)
# Como abrir um Pull Request (PR)
Um pull request (PR) permite que você envie alterações do seu fork do GitHub para o repositório principal do freeCodeCamp.org. Depois de terminar de fazer alterações no código, você pode seguir essas diretrizes para abrir um PR.
@ -6,7 +6,7 @@ Um pull request (PR) permite que você envie alterações do seu fork do GitHub
## Prepare um bom título para o PR
Recomendamos usar [título e mensagens convencionais](https://www.conventionalcommits.org/) para commits e pull request. The convention has the following format:
Recomendamos usar [título e mensagens convencionais](https://www.conventionalcommits.org/) para commits e pull request. A convenção tem o seguinte formato:
> `<type>([escopo(s) opcional(is)]): <description>`
>
@ -16,35 +16,35 @@ Recomendamos usar [título e mensagens convencionais](https://www.conventionalco
Quando estiver abrindo um Pull Request (PR), você pode usar a referência abaixo para determinar o tipo, escopo (opcional) e a descrição.
**Type:**
**Tipo:**
| Tipo | When to select |
| Tipo | Quando selecionar |
|:----- |:-------------------------------------------------------------------------------------- |
| fix | Funcionalidade mudada ou atualizada/melhorada, testes, a explicação de uma lição, etc. |
| feat | Only if you are adding new functionality, tests, etc. |
| feat | Somente se você estiver adicionando novas funcionalidades, testes, etc. |
| chore | Mudanças não relacionadas ao código, testes ou explicação de uma lição. |
| docs | Changes to `/docs` directory or the contributing guidelines, etc. |
| docs | Mudanças no diretório `/docs` ou nas diretrizes de contribuição, etc. |
**Escopo:**
Você pode selecionar um escopo a partir [desta lista de etiquetas](https://github.com/freeCodeCamp/freeCodeCamp/labels?q=scope).
**Description:**
**Descrição:**
Escreva pouco (menos de 30 caracteres) e de modo simples. Você pode adicionar mais informações na caixa de descrição do PR e comentários.
Some examples of good PRs titles would be:
Alguns exemplos de bons títulos de PRs seriam:
- `fix(a11y): contraste melhorado da barra de pesquisa`
- `feat: adicionar mais testes aos desafios de HTML e CSS`
- `fix(api,cliente): previnir erros CORS no envio do formulário`
- `docs(i18n): tradução para chinês da configuração local`
## Proposing a Pull Request
## Propondo um Pull Request
1. Once the edits have been committed, you will be prompted to create a pull request on your fork's GitHub Page.
1. Uma vez que as edições tenham sido realizadas, será solicitado que você crie um pull request na página do GitHub do seu fork.
![Image - Compare pull request prompt on GitHub](https://contribute.freecodecamp.org/images/github/compare-pull-request-prompt.png)
![Imagem - Comparar o prompt de pull request no GitHub](https://contribute.freecodecamp.org/images/github/compare-pull-request-prompt.png)
2. Por padrão, todos os pull requests devem ser feitos no repositório principal do freeCodeCamp, branch `main`.
@ -56,7 +56,7 @@ Some examples of good PRs titles would be:
4. No corpo de seu PR, há um resumo mais detalhado das alterações feitas e o motivo.
- You will be presented with a pull request template. É uma checklist que você deve seguir antes de abrir o pull request.
- Você será apresentado com um modelo de pull request. É uma checklist que você deve seguir antes de abrir o pull request.
- Preencha os detalhes como quiser. Essas informações serão revisadas e os revisores decidirão se seu pull request será aceito ou não.
@ -80,7 +80,7 @@ E como sempre, fique à vontade em perguntar na [categoria 'Contribuidores' do f
> [!TIP] Se você vai contribuir com mais pull requests, recomendamos ler as diretrizes sobre [fazer mudanças e sincronizá-las](https://contribute.freecodecamp.org/#/how-to-setup-freecodecamp-locally?id=making-changes-locally) para evitar o apagamento de seu fork.
## Conflicts on a pull request
## Conflitos em um pull request
Conflitos podem surgir porque muitos colaboradores trabalham no repositório, e as alterações podem afetar o seu PR, que está aguardando uma revisão e merge.
@ -100,7 +100,7 @@ Quando se está trabalhando em erros normais e funcionalidades na sua branch `ma
2. Resolva quaisquer conflitos e adicione / edite commits
```console
# Either
# Ou
git add .
git commit -m "chore: resolve conflicts"
@ -119,7 +119,7 @@ Quando se está trabalhando em erros normais e funcionalidades na sua branch `ma
Quando você estiver trabalhando em funcionalidades para nossas próximas branches `next-*` do currículo, você tem que fazer um cherry pick:
1. Make sure your upstream comes in sync with your local:
1. Certifique-se de que seu upstream esteja sincronizado com seu local:
```console
git checkout main
@ -135,12 +135,12 @@ Quando você estiver trabalhando em funcionalidades para nossas próximas branch
```console
git checkout <pr-branch-name>
# example:
# exemplo:
# git checkout feat/add-numpy-video-question
git checkout -b <backup-branch-name>
# example:
# exemplo:
# git checkout -b backup-feat/add-numpy-video-question
git branch -D <pr-branch-name>
@ -151,7 +151,7 @@ Quando você estiver trabalhando em funcionalidades para nossas próximas branch
```console
git checkout -b <backup-branch-name> origin/<pr-branch-name>
# example:
# exemplo:
# git checkout -b backup-feat/add-numpy-video-question origin/feat/add-numpy-video-question
```
@ -170,7 +170,7 @@ Quando você estiver trabalhando em funcionalidades para nossas próximas branch
npm ci
npm run test:curriculum --superblock=<superblock-name>
# example:
# exemplo:
# npm run test:curriculum --superblock=python-for-everybody

60
docs/i18n/portuguese/how-to-proofread-files.md
View File

@ -1,54 +1,54 @@
# How to Proofread Translations
# Como revisar as traduções
Our proofreading team is responsible for ensuring that translations accurately reflect the source text. We trust our proofreaders to ensure that we have very high quality translations.
Nossa equipe de revisão é responsável por garantir que as traduções reflitam com exatidão o texto original. Confiamos em nossos revisores para que tenhamos traduções de alta qualidade.
All our translations are done by hand, by real humans. Proofreading ensures that there is a consistent tone across our all our translated resources like the curriculum.
Todas as nossas traduções são feitas a mão, por humanos reais. A revisão mantém um tom consistente em todos os nossos recursos traduzidos, como o currículo.
To begin proofreading, visit [our translation platform](https://translate.freecodecamp.org) and login. Select "Go to console" in the top navigation bar to switch from the public view to the workspace view.
Para iniciar a revisão, visite [nossa plataforma de tradução](https://translate.freecodecamp.org) e faça o login. Selecione "Go to console" na barra de navegação superior para mudar da visualização pública para a visualização do espaço de trabalho.
## Select a File
## Selecione um arquivo
You should see the list of projects you have been granted access to. Select the project that you would like to proofread, then select the language.
Você deve ver a lista de projetos aos quais foi concedido acesso. Selecione o projeto que você gostaria de revisar e, em seguida, selecione o idioma.
![Image - Proofreading File Tree](https://contribute.freecodecamp.org/images/crowdin/proof-file-tree.png)
![Imagem - Estrutura dos arquivos de revisão](https://contribute.freecodecamp.org/images/crowdin/proof-file-tree.png)
You should now see the list of available files. Choose your file by selecting the `Proofread` button on the right of that file, then choosing `Proofreading` from the drop-down menu that appears.
Agora você deve ver a lista de arquivos disponíveis. Escolha seu arquivo selecionando o botão `Proofread` à direita do arquivo, depois escolha `Proofreading` no menu que aparece.
> [!NOTE] If you are in this workspace view, but want to work on [translating a file](./how-to-translate-files.md) instead of proofreading, you may select `Crowdsourcing` from the dropdown menu instead.
> [!NOTE] Se você estiver nesta visão de espaço de trabalho, mas quiser [traduzir um arquivo](./how-to-translate-files.md) em vez de revisar, você pode selecionar `Crowdsourcing` no menu suspenso.
## Proofread Translations
## Traduções revisadas
![Image - Proofreading View](https://contribute.freecodecamp.org/images/crowdin/proofread.png)
![Imagem - Visualização da Revisão](https://contribute.freecodecamp.org/images/crowdin/proofread.png)
<!--Add proofread/crowdsource button to the image-->
Here you will see the list of strings in the selected file, with their related translations. The translation that is displayed here is the translation that has received the highest score (between upvotes and downvotes) from the translation community.
Aqui você verá a lista de strings do arquivo selecionado, com suas respectivas traduções. A tradução que é exibida aqui é a tradução que recebeu a maior pontuação (entre votos positivos e negativos) da comunidade de tradução.
While you can view _all_ proposed translations for a given string, the community scores (determined by the upvotes and downvotes) should be taken into consideration when choosing which translation to approve. The community can review proposed translations and recommend which one is most accurate and clear.
Enquanto você pode ver _todas_ as traduções propostas para uma determinada string, a pontuação da comunidade (determinada pelos votos positivos e negativos) deve ser levada em consideração na escolha da tradução a ser aprovada. A comunidade pode revisar as traduções propostas e recomendar qual delas é a mais precisa e clara.
1. This is the original string (in English).
2. This is the matching translated string. The most popular translation proposal, based on upvotes and downvotes, will be displayed here.
3. Clicking this checkmark button will approve that translation.
4. Crowdin will display the status of each string. `Done` means a translation has been approved and will be downloaded on our next Crowdin pull. `Todo` means the string has not been proofread. `Hidden` means the string is locked and _should not be translated_. `Comment` means the string has a related comment.
5. Translations can be selected with the checkboxes and approved here in one bulk action.
6. You can view the community proposed translations, their popularity scores, and Crowdin suggested translations here.
7. This button shows/hides the right-hand side display pane, where you can view translations, comments, translation memory, and glossary terms.
8. Crowdin displays error messages here from the quality assurance checks. In other words, if something does not seem correct in the translation, Crowdin will notify you. These translations should be approved with care.
1. Esta é a string original (em inglês).
2. Esta é a string de tradução correspondente. A proposta de tradução mais popular, baseada em votos a favor e contra, será exibida aqui.
3. Clicando neste botão de verificação, a tradução será aprovada.
4. Crowdin exibirá o estado de cada string. `Done` significa que uma tradução foi aprovada e será baixada em nosso próximo Crowdin pull. `Todo` significa que a string não foi revisada. `Hidden` significa que a string está bloqueada e _não deve ser traduzida_. `Comment` significa que a string tem um comentário relacionado.
5. As traduções podem ser selecionadas com as caixas de seleção e aprovadas aqui com uma única ação.
6. Você pode ver as traduções propostas pela comunidade, suas pontuações de popularidade, e traduções sugeridas pela Crowdin aqui.
7. Este botão mostra/esconde o painel do lado direito, onde você pode ver traduções, comentários, memória de tradução e termos do glossário.
8. Crowdin exibe aqui mensagens de erro a partir das verificações de garantia de qualidade. Em outras palavras, se algo não parecer correto na tradução, o Crowdin notificará você. Estas traduções devem ser aprovadas com cuidado.
No additional actions are required once a file has been proofread.
Nenhuma ação adicional é necessária quando o arquivo terminou de ser revisado.
> [!NOTE] Approving a string in the proofreading view will mark it as complete and it will be downloaded in our next pull from Crowdin to GitHub.
> [!NOTE] A aprovação de uma string na visualização de revisão a marcará como completa e será baixada em nosso próximo pull da Crowdin para o GitHub.
## Becoming a proofreader
## Tornando-se um revisor
If you have any questions, or are interested in becoming a proofreader, feel free to reach out to us in our [contributors chat room](https://chat.freecodecamp.org/channel/contributors). We will typically grant you proofreading access if you have been contributing to freeCodeCamp for a while.
Se você tiver qualquer dúvida, ou estiver interessado em se tornar um revisor, sinta-se a vontade em nos enviar uma mensagem no nosso [ chat de contribuidores](https://chat.freecodecamp.org/channel/contributors). Vamos te dar acesso se você já estiver contribuindo para freeCodeCamp por um tempo.
Our staff team and community moderators teams are always looking for kind volunteers like you who help us make high quality translations available to the world.
Nosso time de desenvolvedores e times de moderadores da comunidade está sempre procurando por voluntários gentis como você, que nos ajuda a deixar traduções de alta qualidade disponíveis para o mundo.
> [!NOTE] Crowdin will allow you to approve your translations. In general, it is best to allow another proofreader to review your proposed translations as extra safety to ensure there are no errors.
> [!NOTE] O Crowdin permitirá que você aprove suas traduções. Em geral, é melhor permitir que outro revisor reveja suas traduções propostas como segurança extra para garantir que não haja erros.
## Creating a channel on Chat for a world language
## Criando um canal no chat para um idioma
For the most part we encourage you to use the [contributors chat](https://chat.freecodecamp.org/channel/contributors) room for all correspondence. However if the team of volunteer translators grows for a certain language, we can consider creating additional break-out channel for the language.
Para a maior parte das mensagens, encorajamos você a usar o [chat de contribuidores](https://chat.freecodecamp.org/channel/contributors) para todas as interações. Entretanto, se o time de voluntários crescer para um idioma específico, nós consideramos criar um canal adicional para o idioma.
If you are already a proofreader and are interested in having a dedicated channel on our chat servers for a specific language, [fill out this form](https://forms.gle/XU5CyutrYCgDYaVZA).
Se você já é um revisor e está interessado em ter um canal dedicado a um idioma específico, [preencha nosso formulário](https://forms.gle/XU5CyutrYCgDYaVZA).

110
docs/i18n/portuguese/how-to-setup-freecodecamp-locally.md
View File

@ -1,18 +1,18 @@
Follow these guidelines for setting up freeCodeCamp locally on your system. This is highly recommended if you want to contribute regularly.
Siga estas diretrizes para configurar o freeCodeCamp localmente no seu sistema. Isso é altamente recomendado se você quer contribuir regularmente.
Alguns destes fluxos de trabalho de contribuição — como correção de erros na base de código ou currículo — necessitam do freeCodeCamp executando localmente em seu computador.
> [!TIP] If you are not interested in setting up freeCodeCamp locally, consider using Gitpod, a free online dev environment.
> [!TIP] Se você não tem interesse em configurar o freeCodeCamp localmente, considere usar o Gitpod, um ambiente gratuito de desenvolvimento online.
>
> [![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/freeCodeCamp/freeCodeCamp)
> [![Abrir no Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/freeCodeCamp/freeCodeCamp)
>
> (Starts a ready-to-code dev environment for freeCodeCamp in your browser.)
> (Inicia um ambiente de desenvolvimento pronto para programação em seu navegador.)
### How to prepare your local machine
### Como preparar sua máquina local
Start by installing the prerequisite software for your operating system.
Comece instalando o software pré-requisito para seu sistema operacional.
Apoiamos principalmente o desenvolvimento em sistemas Linux e Unix. Our staff and community contributors regularly work with the codebase using tools installed on Ubuntu and macOS.
Apoiamos principalmente o desenvolvimento em sistemas Linux e Unix. Nossa equipe e colaboradores da comunidade trabalham regularmente com a base de código usando ferramentas instaladas no Ubuntu e no macOS.
Também suportamos o Windows 10 via WSL2, que você pode preparar [lendo este guia](/how-to-setup-wsl).
@ -20,13 +20,13 @@ Alguns membros da comunidade também desenvolvem no Windows 10 nativamente com G
#### Pré-requisitos:
| Prerequisite | Version | Notes |
| --------------------------------------------------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------- |
| Pré-requisito | Versão | Observações |
| --------------------------------------------------------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------- |
| [Node.js](http://nodejs.org) | `14.x` | Usamos a versão "Active LTS". Consulte [Agenda LTS](https://nodejs.org/en/about/releases/). |
| npm (comes bundled with Node) | `6.x` | O `npm` não tem lançamentos em LTS. Usamos a versão incluída na Active LTS do Node.js. |
| [MongoDB Community Server](https://docs.mongodb.com/manual/administration/install-community/) | `4.0.x` | - |
| npm (vem junto com o Node) | `6.x` | O `npm` não tem lançamentos em LTS. Usamos a versão incluída na Active LTS do Node.js. |
| [Servidor da Comunidade MongoDB](https://docs.mongodb.com/manual/administration/install-community/) | `4.0.x` | - |
> [!ATTENTION] Se você tem uma versão diferente, instale a versão recomendada. We can only support installation issues for recommended versions. See [troubleshooting](#troubleshooting) for details.
> [!ATTENTION] Se você tem uma versão diferente, instale a versão recomendada. Só podemos suportar problemas de instalação para versões recomendadas. Veja [solução de problemas](#troubleshooting) para detalhes.
Se o Node.js já estiver instalado em sua máquina, execute os comandos a seguir para validar as versões:
@ -45,7 +45,7 @@ Depois de estar com os pré-requisitos instalados, você precisa preparar seu am
2. (Opcional mas recomendado) [Configure uma chave SSH](https://help.github.com/articles/generating-an-ssh-key/) para o GitHub.
3. Install a code editor of your choice.
3. Instale um editor de código de sua escolha.
Nós recomendamos muito usar o [Visual Studio Code](https://code.visualstudio.com/) ou o [Atom](https://atom.io/). São ótimos editores gratuitos de código aberto.
@ -55,7 +55,7 @@ Depois de estar com os pré-requisitos instalados, você precisa preparar seu am
> [!TIP] Não ignore nenhum erro de linting. Eles têm como objetivo **ajudar** você e garantir uma base de código simples e limpa.
## Fork the repository on GitHub
## Faça fork do repositório no GitHub
[Forking](https://help.github.com/articles/about-forks/) é uma etapa onde você obtém sua própria cópia do repositório principal do freeCodeCamp (vulgo _repo_) no GitHub.
@ -69,7 +69,7 @@ Isso é essencial, pois permite que você trabalhe em sua própria cópia do fre
1. Vá até o repositório freeCodeCamp no GitHub: <https://github.com/freeCodeCamp/freeCodeCamp>
2. Click the "Fork" Button in the upper right-hand corner of the interface ([More Details Here](https://help.github.com/articles/fork-a-repo/))
2. Clique no botão "Fork" no canto superior direito da interface ([Mais detalhes aqui](https://help.github.com/articles/fork-a-repo/))
3. Depois que o repositório recebeu um fork, você será redirecionado a cópia do repositório freeCodeCamp em `https://github.com/YOUR_USER_NAME/freeCodeCamp`(`YOUR_USER_NAME` será substituído pelo seu nome de usuário do GitHub.)
@ -82,7 +82,7 @@ Isso é essencial, pois permite que você trabalhe em sua própria cópia do fre
<img src="https://raw.githubusercontent.com/freeCodeCamp/freeCodeCamp/main/docs/images/github/how-to-fork-freeCodeCamp.gif" alt="Como criar um fork do freeCodeCamp no GitHub" />
</details>
## Clone your fork from GitHub
## Clone o seu fork no GitHub
[Clonar](https://help.github.com/articles/cloning-a-repository/) é ** a ação de fazer o download de uma cópia** de um repositório de um local `remoto` que pertence a você ou a outra pessoa. No seu caso, este local remoto é o seu `fork` do repositório freeCodeCamp que deve estar disponível em `https://github.com/YOUR_USER_NAME/freeCodeCamp`. (`YOUR_USER_NAME` será substituído pelo seu nome de usuário do GitHub.)
@ -126,7 +126,7 @@ Agora que você baixou uma cópia do seu fork, será necessário configurar um r
git remote add upstream https://github.com/freeCodeCamp/freeCodeCamp.git
```
3. Ensure the configuration looks correct:
3. Certifique-se de que a configuração esteja correta:
```console
git remote -v
@ -141,7 +141,7 @@ Agora que você baixou uma cópia do seu fork, será necessário configurar um r
upstream https://github.com/freeCodeCamp/freeCodeCamp.git (push)
```
## Running freeCodeCamp locally
## Executando freeCodeCamp localmente
Agora que você tem uma cópia local do freeCodeCamp, você pode seguir estas instruções para executá-lo localmente. Isso permitirá que você:
@ -157,9 +157,9 @@ E, como sempre, fique à vontade em perguntar na [categoria 'Contribuidores' do
>
> Você pode sempre retornar a esta parte das instruções depois. Você deve **apenas** ignorar este passo se não precisa executar os aplicativos em sua máquina.
>
> [Skip to making changes](#making-changes-locally).
> [Pular para fazer alterações](#making-changes-locally).
### Configuring dependencies
### Configurando dependências
#### Etapa 1: Configure o arquivo de variável de ambiente
@ -196,19 +196,19 @@ Antes de executar o aplicativo localmente, você precisará iniciar o serviço M
Inicie o servidor do MongoDB em um terminal separado:
- On macOS & Ubuntu:
- No macOS e no Ubuntu:
```console
mongod
```
- On Windows, you must specify the full path to the `mongod` binary
- No Windows, você deve especificar o caminho completo para o `binário do mongod`
```console
"C:\Program Files\MongoDB\Server\3.6\bin\mongod"
```
Make sure to replace `3.6` with the version you have installed
Certifique-se de substituir `3.6` pela versão que você instalou
> [!TIP] Você pode evitar ter que executar o MongoDB toda vez instalando-o como um serviço em segundo plano. Você pode [aprender mais sobre isso na documentação para seu OS](https://docs.mongodb.com/manual/administration/install-community/)
@ -228,13 +228,13 @@ npm run develop
Este único comando vai disparar todos os serviços, incluindo o servidor API e os aplicativos do cliente disponíveis para você trabalhar.
> [!NOTE] Uma vez pronto, abra um navegador e **acesse <http://localhost:8000>**. Se o aplicativo carregar, parabéns - você está com tudo configurado! You now have a copy of freeCodeCamp's entire learning platform running on your local machine.
> [!NOTE] Uma vez pronto, abra um navegador e **acesse <http://localhost:8000>**. Se o aplicativo carregar, parabéns - você está com tudo configurado! Agora você tem uma cópia da plataforma do freeCodeCamp de aprendizagem inteira rodando em sua máquina local.
> [!TIP] The API Server serves APIs at `http://localhost:3000`. The Gatsby app serves the client application at `http://localhost:8000`
> [!TIP] O API Server serve APIs em `http://localhost:3000`. O aplicativo Gatsby atende o aplicativo cliente em `http://localhost:8000`
> If you visit <http://localhost:3000/explorer> you should see the available APIs.
> Se você visitar <http://localhost:3000/explorer> poderá ver as APIs disponíveis.
## Sign in with a local user
## Entre com um usuário local
Sua configuração local preenche automaticamente um usuário local no banco de dados. Clicar no botão `Sign In` vai autenticá-lo automaticamente no aplicativo local.
@ -257,13 +257,13 @@ Agora você pode fazer alterações nos arquivos e fazer commit das suas altera
Siga estes passos:
1. Validate that you are on the `main` branch:
1. Certifique-se que está no branch `main`:
```console
git status
```
You should get an output like this:
Você deve ver um resultado como este:
```console
Na branch main
@ -272,7 +272,7 @@ Siga estes passos:
nada para enviar no commit, diretório de trabalho limpo
```
If you are not on main or your working directory is not clean, resolve any outstanding files/commits and checkout `main`:
Se você não está no main ou seu diretório de trabalho não está limpo, resolva quaisquer arquivos/commits e saia do `main`:
```console
git checkout main
@ -284,7 +284,7 @@ Siga estes passos:
>
> Certifique-se de que foi feito um merge no seu pull request por um moderador antes de executar este passo. Para evitar essa situação, você **sempre** deve trabalhar em uma brach que não seja a `main`.
This step **will sync the latest changes** from the main repository of freeCodeCamp. É importante fazer um rebase em sua branch usando `upstream/main` frequentemente para evitar conflitos depois.
Este passo **irá sincronizar as últimas alterações** do repositório principal do freeCodeCamp. É importante fazer um rebase em sua branch usando `upstream/main` frequentemente para evitar conflitos depois.
Atualize sua cópia local do repositório upstream do freeCodeCamp:
@ -322,7 +322,7 @@ Siga estes passos:
git checkout -b fix/update-guide-for-xyz
```
Your branch name should start with a `fix/`, `feat/`, `docs/`, etc. Avoid using issue numbers in branches. Keep them short, meaningful and unique.
Seu nome de branch deve começar com `fix/`, `feat/`, `docs/`, etc. Evite usar números de issues em branches. Mantenha-os curtos, significativos e únicos.
Alguns exemplos de bons nomes para branches são:
@ -336,17 +336,17 @@ Siga estes passos:
4. Edite páginas e trabalhe no código em seu editor de texto favorito.
5. Once you are happy with the changes you should optionally run freeCodeCamp locally to preview the changes.
5. Quando estiver satisfeito com as alterações, você deve opcionalmente executar o freeCodeCamp localmente para visualizar as alterações.
6. Make sure you fix any errors and check the formatting of your changes.
6. Certifique-se de corrigir quaisquer erros e verificar a formatação de suas alterações.
7. Check and confirm the files you are updating:
7. Verifique e confirme os arquivos que você está atualizando:
```console
git status
```
This should show a list of `unstaged` files that you have edited.
Isso deve mostrar uma lista dos arquivos `não executados` que você editou.
```console
Na branch feat/documentation
@ -371,19 +371,19 @@ Siga estes passos:
git add caminho/para/meu/arquivo/alterado.ext
```
Or you can add all the `unstaged` files to the staging area:
Ou você pode adicionar todos os arquivos `não preparados` para a área de preparação:
```console
git add .
```
Only the files that were moved to the staging area will be added when you make a commit.
Apenas os arquivos que foram movidos para a área de staging serão adicionados quando você fizer um commit.
```console
git status
```
Output:
Resultado:
```console
On branch feat/documentation
@ -398,24 +398,24 @@ Siga estes passos:
modified: docs/how-to-work-on-guide-articles.md
```
Now, you can commit your changes with a short message like so:
Agora, você pode fazer o commit das alterações com uma pequena mensagem assim:
```console
git commit -m "fix: my short commit message"
git commit -m "fix: minha curta mensagem de commit"
```
Some examples:
Alguns exemplos:
```md
fix: update guide article for Java - for loop
feat: add guide article for alexa skills
```
Optional:
Opcional:
É altamente recomendável fazer uma mensagem convencional de commit. This is a good practice that you will see on some of the popular Open Source repositories. Como um desenvolvedor, isso incentiva você a seguir os padrões.
É altamente recomendável fazer uma mensagem convencional de commit. Esta é uma boa prática que você verá em alguns dos repositórios de código aberto populares. Como um desenvolvedor, isso incentiva você a seguir os padrões.
Some examples of conventional commit messages are:
Alguns exemplos de mensagens convencionais de commit são:
```md
correção: atualizar artigo do guia HTML
@ -426,7 +426,7 @@ Siga estes passos:
Escreva pouco, não mais do que 50 caracteres. Você sempre pode adicionar informações extras na descrição da mensagem de commit.
This does not take any additional time than an unconventional message like 'update file' or 'add index.md'
Isso não leva mais tempo do que uma mensagem não convencional como 'atualizar arquivo' ou 'adicionar index.md'
Você pode aprender mais sobre o motivo de usar commits convencionais [aqui](https://www.conventionalcommits.org/en/v1.0.0-beta.2/#why-use-conventional-commits).
@ -436,15 +436,15 @@ Siga estes passos:
git commit --amend
```
This will open up a default text editor like `nano` or `vi` where you can edit the commit message title and add/edit the description.
Isso irá abrir um editor de texto padrão, como `nano` ou `vi` onde você pode editar o título da mensagem de commit e adicionar/editar a descrição.
10. Next, you can push your changes to your fork:
10. Em seguida, você pode fazer push das suas alterações no seu fork:
```console
git push origin branch/nome-aqui
```
## Proposing a Pull Request (PR)
## Propondo um Pull Request (PR)
Após ter feito as alterações, veja [como abrir um Pull Request](how-to-open-a-pull-request.md).
@ -452,11 +452,11 @@ Após ter feito as alterações, veja [como abrir um Pull Request](how-to-open-a
Uma rápida referência aos comandos que você precisará ao trabalhar localmente.
| command | descrição |
| comando | descrição |
| -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| `npm ci` | Instala / reinstala todas as dependências e inicializa os diferentes serviços. |
| `npm run seed` | Parses all the challenge markdown files and inserts them into MongoDB. |
| `npm run develop` | Starts the freeCodeCamp API Server and Client Applications. |
| `npm run seed` | Analisa todos os arquivos Markdown do desafio e os insere no MongoDB. |
| `npm run develop` | Inicia o servidor de API freeCodeCamp e aplicativos Cliente. |
| `npm run storybook` | Inicia o Storybook para o desenvolvimento da biblioteca de componentes. |
| `npm test` | Executa todos os testes JS no sistema, incluindo cliente, servidor, lint e testes dos desafios. |
| `npm run test-client` | Executa o conjunto de testes do cliente. |
@ -468,9 +468,9 @@ Uma rápida referência aos comandos que você precisará ao trabalhar localment
| `npm run e2e` | Executa os testes de ponta a ponta do Cypress. |
| `npm run clean` | Desinstala todas as dependências e limpa os caches. |
## Troubleshooting
## Solução de problemas
### Issues with installing the recommended prerequisites
### Problemas com a instalação dos pré-requisitos recomendados
Desenvolvemos regularmente nos sistemas mais recentes e populares, como o macOS 10.15, o Ubuntu 18.04 e o Windows 10 (com WSL2).
@ -546,7 +546,7 @@ A primeira configuração pode demorar um pouco, dependendo da largura de banda
> [!NOTE] Se estiver usando dispositivos da Apple com o chip M1 para executar a aplicação localmente, sugerimos usar o Node v14.7 ou uma versão mais recente. Do contrário, você poderá ter problemas com dependências como o Sharp.
## Getting Help
## Obtendo ajuda
Se você está com dificuldades e precisa de ajuda, fique à vontade em perguntar na categoria ['Contribuidores' em nosso fórum](https://forum.freecodecamp.org/c/contributors) ou [no chat de contribuidores](https://chat.freecodecamp.org/channel/contributors).

34
docs/i18n/portuguese/how-to-setup-wsl.md
View File

@ -2,9 +2,9 @@
> [!NOTE] Antes de seguir estas instruções, verifique se o sistema atende aos requisitos
>
> **WSL 2**: Windows 10 64-bit (Version 2004, Build 19041 or higher) - available for all distributions including Windows 10 Home.
> **WSL 2**: Windows 10 64-bit (Versão 2004, Build 19041 ou superior) - disponível para todas as distribuições, incluindo o Windows 10 Home.
>
> **Docker Desktop for Windows**: See respective requirements for [Windows 10 Pro](https://docs.docker.com/docker-for-windows/install/#system-requirements) and [Windows 10 Home](https://docs.docker.com/docker-for-windows/install-windows-home/#system-requirements)
> **Docker Desktop para Windows**: Veja os respectivos requisitos para [Windows 10 Pro](https://docs.docker.com/docker-for-windows/install/#system-requirements) e [Windows 10 Home](https://docs.docker.com/docker-for-windows/install-windows-home/#system-requirements)
Este guia abrange algumas etapas comuns sobre a instalação do WSL2. Uma vez resolvidos alguns dos problemas comuns com o WSL2, você deve seguir o nosso [guia de instalação local](https://contribute.freecodecamp.org/#/how-to-setup-freecodecamp-locally) para trabalhar com o freeCodeCamp no Windows executando uma distro WSL como o Ubuntu.
@ -14,7 +14,7 @@ Siga as instruções na [documentação oficial](https://docs.microsoft.com/en-u
## Instale o Ubuntu
1. We recommended using Ubuntu-18.04 or above with WSL2.
1. Recomendamos usar Ubuntu-18.04 ou superior com WSL2.
> [!NOTE]
>
@ -40,19 +40,19 @@ O Git vem pré-instalado com Ubuntu 18.04, verifique sua versão do Git com `git
git version 2.25.1
```
(Optional but recommended) You can now proceed to [setting up your ssh keys](https://help.github.com/articles/generating-an-ssh-key) with GitHub.
(Opcional, mas recomendado) Agora você pode prosseguir para [configurar suas chaves ssh](https://help.github.com/articles/generating-an-ssh-key) com o GitHub.
## Installing a Code Editor
## Instalando um Editor de Código
We highly recommend installing [Visual Studio Code](https://code.visualstudio.com) on Windows 10. Tem um ótimo suporte para WSL e instala automaticamente todas as extensões necessárias na distribuição WSL.
É altamente recomendável instalar o [Visual Studio Code](https://code.visualstudio.com) no Windows 10. Tem um ótimo suporte para WSL e instala automaticamente todas as extensões necessárias na distribuição WSL.
Essentially, you will edit and store your code on Ubuntu-18.04 with VS Code installed on Windows.
Essencialmente, você irá editar e armazenar seu código no Ubuntu-18.04 com o VS Code instalado no Windows.
Se você usa o [IntelliJ Idea](https://www.jetbrains.com/idea/), talvez precise atualizar seu interpretador do Node e seu gerenciador de pacotes NPM pelo que estiver instalado em sua distro WSL.
Você pode checar essas configurações indo em Settings > Languages & Frameworks > Node.js and NPM.
## Installing Docker Desktop
## Instalando o Docker Desktop
**O Docker Desktop para Windows** permite instalar e executar banco de dados e serviços como MongoDB, NGINX, etc. Isso é útil para evitar problemas comuns com a instalação do MongoDB ou outros serviços diretamente no Windows ou WSL2.
@ -70,7 +70,7 @@ Isso faz com que os contêineres sejam executados no lado do WSL em vez de serem
Depois de ter configurado o Docker Desktop para trabalhar com o WSL2, siga essas etapas para iniciar um serviço no MongoDB:
1. Launch a new Ubuntu-18.04 terminal
1. Inicie um novo terminal Ubuntu-18.04
2. Pull `MongoDB 4.0.x` do dockerhub
@ -89,9 +89,9 @@ Depois de ter configurado o Docker Desktop para trabalhar com o WSL2, siga essas
-d mongo:4.0
```
4. You can now access the service from both Windows or Ubuntu at `mongodb://localhost:27017`.
4. Agora você pode acessar o serviço no Windows ou Ubuntu em `mongodb://localhost:27017`.
## Installing Node.js and npm
## Instalando Node.js e npm
Recomendamos que você instale a versão LTS para Node.js com um gerenciador de versões do node - [nvm](https://github.com/nvm-sh/nvm#installing-and-updating).
@ -100,12 +100,12 @@ Uma vez instalado, use esses comandos para instalar e usar a versão do Node.js,
```console
nvm install --lts
# OR
# OU
# nvm install <version>
nvm install 14
# Usage
# Uso
# nvm use <version>
nvm use 12
@ -123,11 +123,11 @@ Agora que você instalou os pré-requisitos, siga [nosso guia de instalação lo
> [!WARNING]
>
> Por favor note que, neste momento, a configuração para testes do Cypress (e necessidades relacionadas à GUI) são um trabalho em andamento. You should still be able to work on most of the codebase.
> Por favor note que, neste momento, a configuração para testes do Cypress (e necessidades relacionadas à GUI) são um trabalho em andamento. Você ainda deve ser capaz de trabalhar na maior parte do código.
## Useful Links
## Links Úteis
- [Configuração de desenvolvimento WSL2 com Ubuntu 20.04, Node.js, MongoDB, VS Code e Docker](https://devlog.sh/wsl2-dev-setup-with-ubuntu-nodejs-mongodb-and-docker) - um artigo de Mrugesh Mohapatra (Desenvolvedor de Equipe na freeCodeCamp.org)
- Frequently asked questions on:
- Perguntas frequentes sobre:
- [Subsistema Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/faq)
- [Docker Desktop for Windows](https://docs.docker.com/docker-for-windows/faqs)
- [Docker Desktop para Windows](https://docs.docker.com/docker-for-windows/faqs)

44
docs/i18n/portuguese/how-to-test-translations-locally.md
View File

@ -1,21 +1,21 @@
# How to Test Translations Locally
# Como testar traduções localmente
> [!NOTE] This process is not required, but documented in case you would like to preview what your translations will look like.
> [!NOTE] Esse processo não é obrigatório, mas documentado caso você queira visualizar como suas traduções ficarão.
If you would like to test your translations on a local instance of the freeCodeCamp `/learn` site, first ensure you have [set up the codebase](how-to-setup-freecodecamp-locally.md).
Se você gostaria de testar suas traduções em uma instância local do site FreeCodeCamp `/learn`, primeiro certifique-se de que você tem que [configurar a base de código](how-to-setup-freecodecamp-locally.md).
## Enabling a Language
## Habilitando um idioma
There are a few steps to take in order to allow the codebase to build in your desired language.
Existem algumas etapas a serem seguidas para permitir que a base de código seja compilada no idioma desejado.
First, visit the `config/i18n/all-langs.js` file to add the language to the available languages list and configure the values. There are four objects here.
Primeiro, visite o arquivo `config/i18n/all-langs.js` para adicionar o idioma à lista de idiomas disponíveis e configurar os valores. Existem quatro objetos aqui.
- `availableLangs`: For both the `client` and `curriculum` arrays, add the text name of the language. This is the value that will be used in the `.env` file later.
- `i18nextCodes`: These are the ISO language codes for each language. You will need to add the appropriate ISO code for the language you are enabling. These do need to be unique for each language.
- `langDisplayNames`: These are the display names for the language selector in the navigation menu.
- `langCodes`: These are the language codes used for formatting dates and numbers. These should be Unicode CLDR codes instead of ISO codes.
- `availableLangs`: tanto para o array `client` quanto para o array `curriculum`, adicione o nome do idioma. Esse valor é o que será usado no arquivo `.env` depois.
- `i18nextCodes`: esses são os códigos ISO de cada linguagem. Você vai precisar do código ISO apropriado para o idioma que você está habilitando. Eles precisam ser únicos para cada idioma.
- `langDisplayNames`: esses são os nomes dos idiomas que aparecerão para a seleção no menu de navegação.
- `langCodes`: esses são os códigos de idiomas usados para formatar datas e números. Esses deverão ser códigos Unicode CLDR ao invés de códigos ISO.
As an example, if you wanted to enable Dothraki as a language, your `all-langs.js` objects should look like this:
Como um exemplo, se você tivesse que habilitar o idioma Dothraki como seu idioma, os objetos `all-langs.js` devem ficar assim:
```js
const availableLangs = {
@ -48,11 +48,11 @@ const langCodes = {
};
```
Next, open the `client/src/utils/algolia-locale-setup.js` file. This data is used for the search bar that loads `/news` articles. While it is unlikely that you are going to test this functionality, missing the data for your language can lead to errors when attempting to build the codebase locally.
Agora, abra o arquivo `client/src/utils/algolia-locale-setup.js`. Esse dado é usado para a barra de busca que carrega os artigos `/news`. Embora seja improvável que você venha a testar essa funcionalidade, não ter os dados para o seu idioma pode levar a erros quando tentar criar a base de código localmente.
Add an object for your language to the `algoliaIndices` object. You should use the values for the `english` object for local testing, replacing the `english` key with your language's `availableLangs` value.
Adicione um objeto para seu idioma no objeto `algoliaIndices`. Você deve usar os valores do objeto `english` para o teste local, substituindo a chave `english` pelo valor de `availableLangs` do seu idioma.
If you were to add Dothraki:
Se você fosse adicionar Dothraki:
```js
const algoliaIndices = {
@ -79,9 +79,9 @@ const algoliaIndices = {
};
```
Next, you will need to tell the client which certifications are translated, and which are still in English. Open the `utils/is-audited.js` file. Within the `auditedCerts`, add a new key with your language's `availableLangs` value. Assign the value of that key to an array containing the *dashed names* for the certifications that have been translated. Refer to the existing data for those dashed names.
Depois, você precisará informar ao client quais certificações estão traduzidas e quais ainda estão em inglês. Abra o arquivo `utils/is-audited.js`. Dentro de `auditedCerts`, adicione uma nova chave com o valor de `availableLangs` de seu idioma. Atribua o valor daquela chave a um array que contém os *nomes hifenizados* para as certificações foram traduzidas. Consulte os dados existentes para aqueles nomes hifenizados.
Continuing the work to enable Dothraki - we have translated the first three certifications:
Dando continuidade ao trabalho para habilitar o idioma Dothraki – traduzimos as três primeiras certificações:
```js
const auditedCerts = {
@ -113,19 +113,19 @@ const auditedCerts = {
};
```
Finally, in your `.env` file, set `CLIENT_LOCALE` and `CURRICULUM_LOCALE` to your new language (use the `availableLangs` value.)
Por fim, em seu arquivo `.env`, definimos `CLIENT_LOCALE` e `CURRICULUM_LOCALE` com o valor de seu novo idioma (use o valor de `availableLangs`.)
```txt
CLIENT_LOCALE="dothraki"
CURRICULUM_LOCALE="dothraki"
```
## Loading Translations
## Carregando traduções
Because the language has not been approved for production, our scripts are not automatically downloading the translations yet. Only staff have the access to directly download the translations - you are welcome to reach out to us in our [contributors chat room](https://chat.freecodecamp.org/channel/contributors), or you can translate the English markdown files locally for testing purposes.
Como o idioma ainda não foi aprovado para produção, nossos scripts ainda não estão baixando automaticamente as traduções. Somente membros da equipe têm acesso para baixar as traduções diretamente – entre em contato conosco quando quiser em nossa [sala de chat dos contribuidores](https://chat.freecodecamp.org/channel/contributors) ou traduza os arquivos de markdown em inglês localmente para fins de teste.
Once you have the files, you will need to place them in the correct directory. For the curriculum challenges, you should place the certification folders (i.e. `01-responsive-web-design`) within the `curriculum/challenges/{lang}` directory. For our Dothraki translations, this would be `curriculum/challenges/dothraki`. The client translation `.json` files will go in the `client/i18n/locales/{lang}` directory.
Quando tiver os arquivos em mãos, você precisará colocá-los no diretório correto. Para os desafios do currículo, você deve colocar as pastas de certificação (por exemplo, `01-responsive-web-design`) no diretório `curriculum/challenges/{lang}`. Para nossas traduções em Dothraki, esse diretório seria `curriculum/challenges/dothraki`. Os arquivos `.json` de tradução do client vão no diretório `client/i18n/locales/{lang}`.
Once these are in place, you should be able to run `npm run develop` to view your translated version of freeCodeCamp.
Quando estes arquivos estiverem no local certo, você deve poder usar `npm run develop` para ver sua versão traduzida do freeCodeCamp.
> [!ATTENTION] While you may perform translations locally for the purpose of testing, we remind everyone that translations should *not* be submitted through GitHub and should only be done through Crowdin. Be sure to reset your local codebase after you are done testing.
> [!ATTENTION] Embora você possa realizar as traduções localmente para fins de teste, lembramos a todos que as traduções *não* devem ser enviadas pelo GitHub e devem ser feitas somente pelo Crowdin. Certifique-se de reiniciar sua base de código local após realizar os testes.

162
docs/i18n/portuguese/how-to-translate-files.md
View File

@ -1,148 +1,148 @@
# How to Translate freeCodeCamp's resources
# Como traduzir arquivos do freeCodeCamp
It's our dream to provide you with the resources to learn, no matter the world language you speak. To help us with this massive effort, we have integrated our open-source code-base & curriculum with [Crowdin](https://crowdin.com/) - A tool to help us localize our code-base.
É nosso sonho fornecer recursos para você aprender, não importando qual idioma fala. Para nos ajudar com isso, integramos nosso código fonte open-source & com [Crowdin](https://crowdin.com/). Uma ferramenta que nos ajuda traduzir nosso código fonte.
The translation workflow is split into two main activities:
O fluxo de tradução é divido em duas principais atividades:
- **Translating** curriculum files, documentation and UI elements like buttons, labels, etc.:
- **Traduzindo** arquivos do currículo, documentação e elementos de interface como botões, rótulos e etc.:
As a translator you can sign up on [our translation platform](https://translate.freecodecamp.org) and contribute translations in any of the 30+ languages enabled in there.
Como um tradutor você pode se cadastrar em [nossa plataforma de tradução](https://translate.freecodecamp.org) e contribuir com traduções em 30+ idiomas disponíveis.
- **Proofreading** the translations for all of the above.
- **Revisando** as traduções de todo conteúdo.
Proofreaders verify that the community contributed translations are uniform in tone and free of common issues like typos, etc. In short, they ensure that the quality of translations is high. Note that we do not use machine translations for a reason.
Revisores verificam se as traduções da comunidade tem um tom uniforme e não contenham problemas como erros de digitação e etc. Resumidamente, eles garatem a alta qualidade das traduções. Note que nós não usamos máquina nas traduções por um motivo.
> [!WARNING] We are no longer using GitHub to translate files directly, if you are a returning contributor head to our [translation platform](https://translate.freecodecamp.org/) instead.
> [!WARNING] Nós não usamos mais o GitHub para traduzir arquivos diretamente. Se você está voltando a contribuir, se direcione para nossa [plataforma de tradução](https://translate.freecodecamp.org/).
## Prepare yourself for contributions
## Prepare-se para as contribuições
> The freeCodeCamp Localization Roadmap – There Are No Speed Limits
> O roadmap de localização da freeCodeCamp - Não há limites
You can translate as much as you want, when you want. It's only a matter of how much time and energy you are willing to invest as a volunteer translator.
Você pode traduzir o quanto você quer, e quando você puder. O que realmente importa é o quanto de tempo e energia está disposto a investir como um voluntário de tradução.
We just ask that you understand the following:
Nós apenas pedimos que entenda os seguintes pontos:
1. **Translations are a team effort.**
1. **As traduções são um esforço em equipe.**
Translating freeCodeCamp's resources is one of the most fun and rewarding experiences as a contributor, and it works best if you involve your friends and colleagues who speak the same world language as you.
A tradução dos recursos da freeCodeCamp é uma das mais divertidas e gratificantes como um contribuidor, e funciona melhor quando está envolvida em amigos e colegas que falam o mesmo idioma que você.
We recommend joining [our community forum](https://forum.freecodecamp.org/c/contributors/3) and [contributors chat room](https://chat.freecodecamp.org/channel/contributors) with your friends and showing your interest before starting off with translations. Crowdin makes it easy to contribute translations, but it's still a lot of work.
Nós recomendamos que entre [em nosso fórum da comunidade](https://forum.freecodecamp.org/c/contributors/3) e na [sala de chat dos tradutores](https://chat.freecodecamp.org/channel/contributors) com seus amigos e mostre seu interesse antes de começar a traduzir. A ferramenta Crowdin facilita a contribuição com traduções, mas ainda há bastante trabalho.
We want you to enjoy contributing and not burn out or lose interest.
Nós esperamos que você goste de contribuir e não venha a se sentir esgotado ou perder o interesse.
A small group of 4-5 individuals is a good size to start your niche for your world language. You can then recruit even more friends to join the team.
Um grupo pequeno de 4 à 5 indivíduos é um bom tamanho para iniciar o nicho para o seu idioma no mundo. Você pode, então, recrutar cada vez mais amigos para se juntarem ao time.
2. **It costs quite a lot to spin servers for each language.**
2. **Custa muito aos servidores rodar cada linguagem.**
On the surface it might not seem how complicated the technical stack is, but it costs quite a lot to keep the engines running. This includes provisioning additional servers and dedicating staff to look after them.
Na superfície, os componentes técnicos não parecem ser tão complicados, mas, para que os componentes continuem rodando, há um alto custo. Nisto está incluso o provisionamento adicional de servidores e uma equipe dedicada para que possam cuidar deles.
freeCodeCamp.org is committed to providing these for free as always, however we need to prioritize resources for those who need it the most. The last thing we want is to shutdown servers for a language if the translation activity dies off & things become outdated.
A freeCodeCamp.org comprometeu-se em providenciar de forma gratuita como sempre. No entanto, precisamos priorizar os recursos para os que mais necessitam. A última coisa que queremos é desligar os servidores para uma linguagem se a atividade de tradução encerrar e se tornar desatualizada.
Once a language reaches at least a few certifications on the curriculum we can begin deploying the language live on [`/learn`](https://www.freecodecamp.org/learn), while you continue to translate the remaining certifications.
Quando cada linguagem alcançar pelo menos algumas certificações no currículo, nós podemos começar a implantar a linguagem no [`/learn`](https://www.freecodecamp.org/learn) enquanto você continua a traduzir o restante das certificações.
For example, we would want to deploy at least the entire front-end certifications suite when we ship a new world language for the first time.
Por exemplo, gostaríamos de implantar pelo menos todo o conjunto do front-end das certificações quando entregarmos uma nova linguagem pela primeira vez.
3. **But what about the languages not listed on the translation platform?**
3. **E quanto às linguagens que não estão listadas na plataforma de tradução?**
We have looked at our user base and added 30+ most widely spoken languages to the list of enabled languages on the translations platform. Some languages like Chinese and Spanish are already deployed live on **"/learn"** at this moment.
Nós buscamos em nossa base de usuários e adicionamos os mais de 30 idiomas mais falados para a lista de idiomas habilitados na plataforma de traduções. Alguns idiomas, como o chinês e o espanhol já estão implantados no **/learn** neste momento.
Unfortunately, the list does not include hundreds of languages out there. We get dozens of requests from contributors like you every day who want to help translate the site into a language they speak.
Infelizmente, a lista não inclui as centenas de idiomas existentes lá fora. Nós recebemos dezenas de requisições de contribuidores que como você todo dia. Eles também gostariam de ajudar na tradução do site no idioma que falam.
We are definitely looking forward to adding more languages to the list, but as you may already guess, it would only be feasible if we get enough momentum around a world language.
Nós estamos definitivamente torcendo para adicionar mais idiomas na lista, mas, como você já sabe, só seria viável se conseguíssemos um impulso suficiente em torno de um idioma.
If you would like us to include a new world language, we recommend getting your friends excited about this.
Se você gostaria nós incluíssemos um novo idioma, nós recomendamos que você deixe seus amigos animados com isso.
Once you have a small group of people (at least 4-5) interested and committed, we can hop on a call. We will explain all the details and walk you through some of the tools and processes.
Quando você tem um pequeno grupo de pessoas (pelo menos 4-5) interessadas e comprometida, nós podemos entrar em contato. Nós vamos explicar todos os detalhes e orientar você em algumas das ferramenta e processos.
## Getting started
## Primeiros passos
First, make sure you come say "Hi" in our [contributors chat room](https://chat.freecodecamp.org/channel/contributors). We post regular updates about translating resources and answer a lot of your queries in there.
Primeiro, tenha certeza de vir dar uma "Oi" na nossa [sala de chat de tradutores](https://chat.freecodecamp.org/channel/contributors). Nós postamos atualizações regulares sobre recursos de tradução e respondemos à muitas de suas dúvidas lá.
Next, head to our [translation platform](https://translate.freecodecamp.org/) and login (if you have not contributed to translations before, you will need to create an account).
Próximo, vá para a nossa [plataforma de tradução](https://translate.freecodecamp.org/) e faça o login (se você não contribuiu com traduções anteriormente, você precisará criar uma conta).
Finally, go through the detailed walk-thru below to understand the translation tools and workflows at your disposal.
Finalmente, faça o nosso passo a passo abaixo para entender as ferramentas de tradução e fluxos de trabalho à sua disposição.
Happy translating.
Boa tradução.
## Select a Project and File
## Selecione um projeto e um arquivo
Once you visit the translation platform, you should see multiple "projects" available for translation:
Quando você visita a plataforma de tradução, você deve ver múltiplos "projetos" disponíveis para tradução:
1. [Contributing documentation](https://translate.freecodecamp.org/contributing-docs) project, which contains the files for this documentation site.
2. [Coding Curriculum](https://translate.freecodecamp.org/curriculum) project, which contains our challenge files for our curriculum.
3. [Learn User Interface](https://translate.freecodecamp.org/learn-ui) project which contains strings for UI elements like buttons, labels, etc. for our learning platform.
1. Projeto de [Contribuição de documentação](https://translate.freecodecamp.org/contributing-docs), que contém os arquivos para a documentação deste site.
2. Projeto de [Programação do currículo](https://translate.freecodecamp.org/curriculum), que contém nossos arquivos de desafios para nosso curriculum.
3. Projeto de [Interface de aprendizagem do usuário](https://translate.freecodecamp.org/learn-ui), que contém as "strings" para elementos de UI como botões, "labels", etc. para nossa plataforma de aprendizagem.
Select any project you want to contribute to, and you will see a list of available languages for translation.
Selecione qualquer projeto no qual que deseje contribuir e você verá uma lista de idiomas disponíveis para tradução.
![Image - List of available languages](https://contribute.freecodecamp.org/images/crowdin/languages.png)
![Imagem - Lista de idiomas disponíveis](https://contribute.freecodecamp.org/images/crowdin/languages.png)
Select the language you want to work on, and you will see the complete file tree.
Selecione o idioma que deseja trabalhar e você verá a estrutura completa do arquivo.
![Image - List of available files](https://contribute.freecodecamp.org/images/crowdin/file-tree.png)
![Imagem - Lista de arquivos disponíveis](https://contribute.freecodecamp.org/images/crowdin/file-tree.png)
Each file and folder will show a progress bar. The **blue** portion of the progress bar indicates what percentage of the file has been translated, while the **green** portion of the progress bar indicates what percentage of the file has been approved by the proofreading team.
Cada arquivo e pasta aparecerá na barra de progresso. A porção **azul** da barra de progresso indica a porcentagem de tradução do arquivo, enquanto a porção **verde** da barra indica a porcentagem aprovada pelo time de revisão.
Select a file to work on and Crowdin will open the editor view.
Selecione um arquivo para traduzir e o Crowdin vai abrir o editor.
> [!NOTE] When the editor view opens, you will need to click the settings icon (shown as a gear) and switch the 'HTML tags displaying' setting to 'SHOW'. This will ensure you can see tags such as `<code></code>` instead of `<0></0>`.
> [!NOTE] Quando o editor abrir, você precisará clicar no ícone de configurações (mostrado como uma engrenagem) e mudar a configuração 'HTML tags displaying' para 'SHOW'. Isso garantirá que você verá tags como `<code></code>` ao invés de `<0></0>`.
## Translate Curriculum
## Traduzir o currículo
![Image - Editor View](https://contribute.freecodecamp.org/images/crowdin/editor.png)
![Imagem - janela do editor](https://contribute.freecodecamp.org/images/crowdin/editor.png)
Crowdin separates a document into translatable "strings", usually sentences. Each string is translated individually. Referring to the image above:
O Crowdin separa o documento em "strings" traduzíveis, geralmente frases. Cada string é traduzida individualmente. Referente à imagem acima:
1. A string highlighted in green already has a proposed translation.
2. A string highlighted in red does _not_ have a proposed translation.
3. A string with greyed out text is not translatable. This is the case for code blocks and other content that must not be translated. You will be unable to select these strings in the editor.
4. If a contributor has proposed a translation to a string, Crowdin will display those proposals here. You will not be able to save an identical translation - instead, if a translation is accurate, you should click the `+` icon to "upvote" it. An inaccurate translation can be "downvoted" with the `-` icon.
5. Crowdin will recommend translations based on Translation Memory (TM) or Machine Translation (MT). Translation Memory refers to similar or identical strings that we have translated/approved in other files. Machine Translation refers to translations recommended by their integrated library.
6. This is the editor pane, where you may write your proposed translation for the selected string.
7. The currently selected string in the editor will be highlighted in yellow.
8. Here you will see tags indicating the state of the string. `Done` means the string has at least one proposed translation. `Todo` means the string does not have any proposed translations.
9. Here you can see the comments window. If you have questions or concerns about a particular string, you can leave a comment on the string here for other translators to see.
10. These two "pane" buttons will hide the left (document) and right (comments) views.
1. Uma string marcada em verde já tem uma proposta de tradução.
2. Uma string em vermelho ainda _não_ possui uma proposta de tradução.
3. Uma string com texto acinzentado não é traduzível. Esse é o caso para blocos de código e outros conteúdos que não devem ser traduzidos. Você não poderá selecionar essas strings no editor.
4. Se um contribuinte propôs uma tradução para uma string, o Crowdin vai mostrar a proposta aqui. Você não pode salvar uma tradução idêntica - ao invés disso, se a tradução estiver precisa, você deve clicar no ícone `+` para "aprová-la". Uma tradução imprecisa pode ser "desaprovada" com o ícone `-`.
5. O Crowdin vai recomendar traduções baseadas na TM (Translation Memory) ou na MT (Machine Translation). Translation Memory se refere a strings similares ou idênticas que já foram traduzidas/aprovadas em outros arquivos. Machine Translation refere-se a traduções recomendadas por bibliotecas integradas.
6. Esse é o painel do editor, onde você pode propor traduções para a string selecionada.
7. A string selecionada no editor estará marcada em amarelo.
8. Aqui você verá tags indicando o estado da string. `Done` significa que a string possui pelo menos uma proposta de tradução. `Todo` significa que a string não possui nenhuma proposta de tradução.
9. Aqui você pode ver a janela de comentários. Se você tem perguntas ou preocupações acerca de uma string em particular, você pode comentar aqui para que outros tradutores vejam.
10. Esses dois "botões de painel" esconderão o documento à esquerda e os comentários à direita.
> [!NOTE] If you see a hidden string that includes translations, please notify us in the [contributors chat room](https://chat.freecodecamp.org/channel/contributors) so we can remove the translation from memory.
> [!NOTE] Se você encontrar uma string escondida que inclui traduções, notifique-a na [sala de chat dos tradutores](https://chat.freecodecamp.org/channel/contributors) para que possamos remover a tradução da memória.
When you have completed a translation for a string, select the `Save` button to store your translation on Crowdin. Other contributors will then be able to vote on your translation and proofreaders will be able to approve it.
Quando tiver terminado de traduzir uma string, clique em `Save` para salvar sua tradução no Crowdin. Outros contribuintes poderão votar em sua tradução e os revisores poderão aprová-la.
You are welcome to translate as many strings as you like - there are no additional steps required when you complete a full file or propose a new translation. Clicking the `Save` button is all that is needed to store a translation.
Você é bem-vindo para traduzir quantas strings quiser - não há nenhuma etapa adicional requerida quando você completar um arquivo inteiro ou propor uma nova tradução. Clicar em `Save` é tudo que você precisa para salvar sua tradução.
> [!NOTE] If you see something in the English source file that is inaccurate or incorrect, please do not fix it through the translation flow. Instead, leave a comment on the string to notify us that there is a discrepancy, or create a GitHub issue.
> [!NOTE] Se você ver algo no arquivo fonte em inglês que esteja impreciso ou incorreto, não conserte pelo mecanismo de tradução. No lugar, deixe um comentário na string para nos notificar de uma discrepância ou crie uma issue no GitHub.
## Translate Documentation
## Traduzir a documentação
Translating our contributing documentation is a similar flow to translating our curriculum files.
Traduzir nossa documentação de contribuição é similar a traduzir nossos arquivos de currículo.
> [!NOTE] Our contributing documentation is powered by `docsify`, and we have special parsing for message boxes like this one. If you see strings that start with `[!NOTE]`, `[!WARNING]`, or `[!TIP]`, these words should NOT be translated.
> [!NOTE] Nossa documentação de contribuição utiliza `docsify`, e nós temos uma análise especial para caixas de mensagem como essa. Caso veja strings iniciadas com `[!NOTE]`, `[!WARNING]`, ou `[!TIP]`, essas palavras NÃO devem ser traduzidas.
## Rate Translations
## Avaliar traduções
Crowdin allows you to rate the existing proposed translations. If you attempt to save a translation, you may see a message indicating that you cannot save a duplicate translation - this means another contributor has proposed that identical translation. If you agree with that translation, click the `+` button to "upvote" the translation.
O Crowdin permite que você avalie propostas de tradução existentes. Se você tentar salvar uma tradução, você pode ver uma mensagem indicando que você não pode salvar a duplicata de uma tradução - isso significa que outro contribuinte já propôs uma tradução idêntica. Se você concorda com aquela tradução, clique em `+` para "aprová-la".
If you see a translation that is inaccurate or does not provide the same clarity as the original string, click the `-` button to "downvote" the translation.
Se você ver uma tradução que não possui a mesma clareza da string original, clique em `-` para "desaprová-la".
Crowdin uses these votes to give a score to each proposed translation for a string, which helps the proofreading team determine which translation is the best fit for each string.
O Crowdin usa esses votos para pontuar cada proposta de tradução de cada string, o que ajuda o time de revisão a determinar qual tradução é a melhor para cada string.
## Quality Assurance Checks
## Verificações de qualidade
We have enabled some quality assurance steps that will verify a translation is as accurate as possible - this helps our proofreaders review proposed translations.
Nós disponibilizamos algumas verificações de qualidade para assegurar que as traduções estejam precisas - isso ajuda nossos revisores a analisarem as traduções propostas.
When you attempt to save a translation, you may see a warning message appear with a notification regarding your proposed translation.
Quando você tenta salvar uma tradução, talvez veja uma mensagem de aviso aparecer a respeito da sua tradução proposta.
![Image - QA Warning Message](https://contribute.freecodecamp.org/images/crowdin/qa-message.png)
![Imagem - Mensagem de aviso](https://contribute.freecodecamp.org/images/crowdin/qa-message.png)
This message appears when Crowdin's QA system has identified a potential error in the proposed translation. In this example, we have modified the text of a `<code>` tag and Crowdin has caught that.
Essa mensagem aparece quando o sistema QA (Verificação de Qualidade) do Crowdin identificou algum erro em potencial na tradução proposta. Nesse exemplo, nós modificamos o texto da tag `<code>` e o sistema viu isto.
> [!WARNING] You have the option to save a translation in spite of errors. If you do, by clicking "Save Anyway", you should also tag a proofreader or project manager and explain why the QA message needs to be ignored in this case.
> [!WARNING] Você tem a opção de salvar uma tradução apesar dos erros. Se fizer isso, clicando em "Save Anyway", você também deve marcar um revisor ou gerenciador do projeto e explicar o motivo do aviso ter sido ignorado nesse caso.
## Translation Best Practices
## Boas práticas na tradução
Follow these guidelines to ensure our translations are as accurate as possible:
Siga essas diretrizes para se certificar de que nossas traduções estão o mais precisas possível:
- Do not translate the content within `<code>` tags. These tags indicate text that is found in code and should be left in English.
- Do not add additional content. If you feel a challenge requires changes in the text content or additional information, you should propose the changes through a GitHub issue or a pull request that modifies the English file.
- Do not change the order of content.
- Não traduza o conteúdo dentro de tags `<code>`. Essas tags indicam que o texto está formatado para o código e deve ser deixado em inglês.
- Não adicione conteúdo extra. Se você acha que um desafio necessita de mudanças no texto e conteúdo adicional, você deve propor as mudanças através de uma issue no GitHub ou um pull request que modifique o arquivo em inglês.
- Não mude a ordem do conteúdo.
If you have any questions, feel free to reach out to us in our [contributors chat room](https://chat.freecodecamp.org/channel/contributors) and we will be happy to assist you.
Se você tiver alguma dúvida, sinta-se a vontade para entrar em contato conosco através da [sala de chat dos tradutores](https://chat.freecodecamp.org/channel/contributors) e nós ficaremos felizes em te ajudar.

62
docs/i18n/portuguese/how-to-work-on-coding-challenges.md
View File

@ -1,39 +1,39 @@
# How to work on coding challenges
# Como trabalhar em desafios de programação
Our goal is to develop a fun and clear interactive learning experience.
Nosso objetivo é desenvolver uma experiência de aprendizado divertida e interativa.
Designing interactive coding challenges is difficult. It would be much easier to write a lengthy explanation or to create a video tutorial. But for our core curriculum, we're sticking with what works best for most people - a fully interactive, video game-like experience.
Projetar desafios interativos de programação é difícil. Seria muito mais fácil escrever uma explicação longa ou criar um tutorial em vídeo. Mas no nosso currículo principal, estamos buscando o que funciona melhor para a maioria das pessoas - uma experiência de jogo totalmente interativa e parecida com vídeo.
Queremos que os usuários freeCodeCamp atinjam um estado ativo no aprendizado. We want them to build momentum and blast through our curriculum with as few snags as possible. We want them to go into the projects with confidence and gain a wide exposure to programming concepts.
Queremos que os usuários freeCodeCamp atinjam um estado ativo no aprendizado. Queremos que eles sejam impulsionados a percorrer o nosso currículo com o mínimo possível de empecilhos. Nós queremos que eles iniciem os projetos com confiança e adquiram uma ampla exposição aos conceitos de programação.
Note that for Version 7.0 of the freeCodeCamp curriculum, we are moving toward [an entirely project-focused model with a lot more repetition](https://www.freecodecamp.org/news/python-curriculum-is-live/).
Note que para a versão 7.0 do currículo do freeCodeCamp, nós estamos migrando para [um modelo inteiramente focado em projetos e com muito mais repetições](https://www.freecodecamp.org/news/python-curriculum-is-live/).
Creating these challenges requires immense creativity and attention to detail. There's plenty of help available. You'll have support from a whole team of contributors to whom you can bounce ideas off and demo your challenges.
A criação destes desafios exige imensa criatividade e atenção aos pormenores. Há muita ajuda disponível. Você terá o apoio de toda uma equipe de colaboradores para quem você pode buscar ideias e provar seus desafios.
And as always, feel free to ask questions on the ['Contributors' category on our forum](https://forum.freecodecamp.org/c/contributors) or [the contributors chat room](https://chat.freecodecamp.org/channel/contributors).
E como sempre, fique à vontade em perguntar na [categoria 'Contribuidores' do fórum](https://forum.freecodecamp.org/c/contributors) ou [no chat dos contribuidores](https://chat.freecodecamp.org/channel/contributors).
With your help, we can design an interactive coding curriculum that will help millions of people learn to code for years to come.
Com sua ajuda, nós podemos projetar um currículo de programação interativo que ajudará milhões de pessoas a aprender a programar nos próximos anos.
The content for each challenge is stored in its markdown file. This markdown file is later converted to HTML using our tools to create interactive web pages.
O conteúdo para cada desafio é guardado em um arquivo markdown. Este arquivo markdown é posteriormente convertido em HTML usando nossas ferramentas para criar páginas web interativas.
You can find all of freeCodeCamp.org's curricular content in the [`/curriculum/challenges`](https://github.com/freeCodeCamp/freeCodeCamp/tree/main/curriculum/challenges) directory.
Você pode encontrar todo o conteúdo curricular do freeCodeCamp.org no diretório [`/curriculum/challenges`](https://github.com/freeCodeCamp/freeCodeCamp/tree/main/curriculum/challenges).
## Configure as ferramentas para o currículo
Before you work on the curriculum, you would need to set up some tooling to help you test your changes. You can use any option from the below:
Antes de trabalhar no currículo, você precisará configurar algumas ferramentas para ajudá-lo a testar suas alterações. Você pode usar qualquer opção abaixo:
- You can [set up freeCodeCamp locally](how-to-setup-freecodecamp-locally.md). This is **highly recommended** for regular/repeat contributions. This setup allows you to work and test your changes.
- Use o Gitpod, um ambiente gratuito de desenvolvimento on-line. Clicar no botão abaixo irá iniciar um ambiente de desenvolvimento pronto para programar para freeCodeCamp em seu navegador. It only takes a few minutes.
- Você pode [configurar freeCodeCamp localmente](how-to-setup-freecodecamp-locally.md). Isto é **altamente recomendado** para contribuições regulares/repetidas. Esta configuração permite que você trabalhe e teste suas alterações.
- Use o Gitpod, um ambiente gratuito de desenvolvimento on-line. Clicar no botão abaixo irá iniciar um ambiente de desenvolvimento pronto para programar para freeCodeCamp em seu navegador. Leva só alguns minutos.
[![Abra no Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/freeCodeCamp/freeCodeCamp)
- Edite os arquivos na interface do GitHub clicando no ícone do lápis no arquivo correspondente. Embora seja a maneira mais rápida, **não é recomendado**, porque você não pode testar suas alterações no GitHub. If our maintainers conclude that the changes you made need to be tested locally, you would need to follow the methods above instead.
- Edite os arquivos na interface do GitHub clicando no ícone do lápis no arquivo correspondente. Embora seja a maneira mais rápida, **não é recomendado**, porque você não pode testar suas alterações no GitHub. Se nossos mantedores concluirem que as mudanças que você fez precisam ser testadas localmente, você precisará seguir os métods acima.
### Trabalhe em projetos práticos
Os projetos práticos tem algumas ferramentas adicionais para criar novos projetos e passos. Para saber mais, veja [esses documentos](how-to-work-on-practice-projects.md)
## Challenge Template
## Modelo de desafio
````md
---
@ -61,13 +61,13 @@ Texto com instruções para o desafio, em markdown
Testes para executar o código do usuário, em par com o markdown e bloco de código de teste.
```js
Code for test one
Código para o teste um
```
Mais instruções em sintaxe markdown
```js
More code
Mais código
```
# --seed--
@ -81,7 +81,7 @@ Código avaliado antes do código do usuário.
## --after-user-code--
```lang
Code evaluated after the user’s code, and just before the tests
Código avaliado após o código do usuário, e pouco antes dos testes
```
## --seed-contents--
@ -193,7 +193,7 @@ id: 5a474d78df58bafeb3535d34
title: Título do desafio
```
## Naming challenges
## Nomeando desafios
Nomear coisas é difícil. Nós facilitamos com algumas restrições.
@ -207,7 +207,7 @@ Aqui estão alguns exemplos de nomes para desafios:
- Condensar arrays com .reduce
- Usar notação de colchetes para encontrar o primeiro caractere em uma string
## Challenge descriptions/instructions
## Descrições/instruções do desafio
As frases devem ser claras e resumidas com o mínimo de termos técnicos. Se usado, o termo técnico deve ser imediatamente definido em inglês simples.
@ -223,7 +223,7 @@ Não use emojis ou emoticons em desafios. O freeCodeCamp possui uma comunidade g
Substantivos próprios devem começar com letra maiúscula quando possível. Abaixo está uma lista de palavras e como devem aparecem nos desafios.
- JavaScript (capital letters in "J" and "S" and no abbreviations)
- JavaScript (letras maiúsculas em "J" e "S" e sem abreviações)
- Node.js
- Embora às vezes imprecisas, as formas não hifenizadas de 'back end' e 'front end' devem ser usadas, pois são mais amplamente utilizadas.
@ -233,8 +233,8 @@ Cada desafio deve ser resolvido em 120 segundos por um nativo da língua inglesa
Se levar mais do que dois minutos para completar um desafio, você tem duas opções:
- Simplify the challenge, or
- Split the challenge into two challenges.
- Simplifique o desafio, ou
- Divida o desafio em dois desafios.
A regra dos 2 minutos força quem criou o desafio a deixar as instruções resumidas, o código fornecido limpo e seus testes diretos.
@ -260,7 +260,7 @@ Use `parseInt` para converter a variável `realNumber` em um número inteiro.
```
- Referências a nomes de arquivos e caminhos (ex. `package.json`, `src/components`) devem estar entre `` \` ``.
- Blocos de código com várias linhas **devem ser precedidos por uma linha vazia**. A próxima linha deve começar com três crases seguidas imediatamente por uma das [linguagens suportadas](https://prismjs.com/#supported-languages). Para completar o bloco de código, você deve começar uma nova linha que apenas possui três crases e **outra linha vazia**. See example below:
- Blocos de código com várias linhas **devem ser precedidos por uma linha vazia**. A próxima linha deve começar com três crases seguidas imediatamente por uma das [linguagens suportadas](https://prismjs.com/#supported-languages). Para completar o bloco de código, você deve começar uma nova linha que apenas possui três crases e **outra linha vazia**. Veja o exemplo abaixo:
- Os espaços importam no Markdown. Então, recomendamos que os mantenham visíveis no seu editor.
**Observação:** se você for usar um exemplo de códigoem YAML, use `yaml` ao invés de `yml` para a linguagem na direita das crases.
@ -386,10 +386,10 @@ Se você encontrar um problema nas dicas/tópicos de solução de um desafio exi
Faça o passo-a-passo a seguir quando for adicionar novos tópicos de dicas/soluções relacionadas a um desafio.
1. Start by following the same steps for creating a new topic but review the next for creating the title.
1. Comece seguindo os mesmos passos para criar um novo tópico, mas revise o seguinte para criar o título.
2. O título do tópico deve começar com `freeCodeCamp Challenge Guide:` concatenado com o título atual do desafio de currículo. Por exemplo, se o desafio é chamado "`Chunky Monkey`", o título do tópico seria "`freeCodeCamp Challenge Guide: Chunky Monkey`".
3. `camperbot` should be the owner of these topics/posts, so you will need to request an admin to change the ownership of the main post to `camperbot`.
4. Depois que o novo tópico for criado, será criado um id para o tópico do fórum. It is located at the end of the forum topic URL. This id must be added to the frontmatter of the curriculum challenge file via the normal pull request process for the `Get a Hint` button to link to the topic.
3. O `camperbot` deve ser o proprietário destes tópicos/postagens. Então, você precisará solicitar um administrador para alterar a propriedade da postagem principal para `camperbot`.
4. Depois que o novo tópico for criado, será criado um id para o tópico do fórum. Está localizado no final da URL do tópico do fórum. Este id deve ser adicionado ao arquivo de desafio do currículo através do processo normal de pull request para o botão `Obter uma dica` para vincular ao tópico.
### Diretrizes para o conteúdo dos tópicos de dicas e soluções
@ -433,15 +433,15 @@ function myFunc() {
}
````
#### Code Explanation
#### Explicação de Código
- A explicação do código fica aqui
- A explicação do código fica aqui
#### Relevant Links
#### Links relevantes
- [Link Text](link_url_goes_here)
- [Link Text](link_url_goes_here)
- [Texto do link](link_url_goes_here)
- [Texto do link](link_url_goes_here)
</details>
````

106
docs/i18n/portuguese/how-to-work-on-localized-client-webapp.md
View File

@ -1,20 +1,20 @@
# How to work on localized client webapp
# Como trabalhar em um cliente webapp traduzido
The react based client web app that powers our learning platform is built using Gatsby. It is translated into various world languages using [react-i18next](https://react.i18next.com/) and [i18next](https://www.i18next.com/).
O nosso cliente web app com base em React que alimenta nossa plataforma de aprendizado foi criado usando o Gatsby. Ele é traduzido em vários idiomas do mundo todo usando [react-i18next](https://react.i18next.com/) e [i18next](https://www.i18next.com/).
You can learn more about setting up the client application locally for development by following [our local setup guide here](/how-to-setup-freecodecamp-locally). By default the application is available only in English.
Você pode aprender mais sobre configurar o cliente localmente para desenvolvimento seguindo [nosso guia de configuração aqui](/how-to-setup-freecodecamp-locally). Por padrão, a aplicação está disponível somente em inglês.
Once you have setup the project locally you should be able to follow this documentation to run the client in the language of your choice from the list of available languages.
Assim que você tiver o projeto configurado localmente, você poderá seguir essa documentação para rodar o cliente no idioma de sua escolha a partir de uma lista de idiomas disponíveis.
This could be helpful when you are working on a feature that specifically targets something that involves localization, and requires you to validate for instance a button's label in a different language.
Isso pode ser de grande ajuda quando você estiver trabalhando em uma nova feature que envolva tradução, em especial, e que necessite que você valide, por exemplo, uma label de botão em um idioma diferente.
> [!TIP] You do not need to follow this document for translating freeCodeCamp's curriculum or contributing documentation. Read [this guide here](./how-to-translate-files.md) instead.
> [!TIP] Você não precisa seguir esse documento para traduzir o currículo do freeCodeCamp ou contribuir com a documentação. Em vez disso, leia [esse guia aqui](./how-to-translate-files.md).
Let's understand how the i18n frameworks and tooling work.
Vamos entender como o framework i18n e suas ferramentas funcionam.
## File Structure
## Estrutura de arquivos
Most of files for translating the platform are located in the [`client/i18n`](https://github.com/freeCodeCamp/freeCodeCamp/tree/main/client/i18n) folder. Each language has a directory within that containing JSON files with the translations.
A maioria dos arquivos para tradução da plataforma ficam localizados na pasta [`client/i18n`](https://github.com/freeCodeCamp/freeCodeCamp/tree/main/client/i18n). Cada idioma tem uma pasta contendo arquivos JSON com as traduções.
```console
config/i18n
@ -59,29 +59,29 @@ Most of files for translating the platform are located in the [`client/i18n`](ht
└── validate-keys.js
```
Some of these files are translated on our translation platform (Crowdin), some are not.
Alguns desses arquivos estão traduzidos na nossa plataforma de tradução (Crowdin), outros não.
**Files translated on our translation platform:**
**Arquivos traduzidos na nossa plataforma de tradução:**
- The `translations.json` file contains the majority of the text that appears on the user interface elements. The keys are used in the codebase to get the correct text for whatever language is set. This file needs to have the exact same keys in all languages.
- O arquivo `translations.json` contém a maioria do texto que aparece nos elementos de interface de usuário. As chaves são usadas na base de código para obter o texto correto para qualquer idioma definido. Este arquivo precisa ter exatamente as mesmas chaves em todos os idiomas.
- The `intro.json` file contains the key-value pairs for the introduction text on the certification pages.
- O arquivo `intro.json` contém os pares chave-valor para o texto de introdução nas páginas de certificação.
If you want to add/update translations for the keys please [read this guide here](/how-to-translate-files.md).
Se você deseja adicionar/atualizar traduções para as chaves, [leia este guia aqui](/how-to-translate-files.md).
**Files NOT translated on our translations platform:**
**Arquivos NÃO traduzidos na nossa plataforma de tradução:**
- The `motivation.json` files are not required to have the same quotes, compliments, or array length. Just the same JSON structure.
- Os arquivos `motivation.json` não precisam ter as mesmas citações, elogios ou comprimento de array. Apenas a mesma estrutura do JSON.
- The `trending.json` file contains the titles and links for the trending news articles in the website's footer.
- O arquivo `trending.json` contém os títulos e links para os artigos de notícias populares no rodapé do site.
- The `meta-tags.json` file contains the information for our website's meta tag information.
- O arquivo `meta-tags.json` contém as informações para a tag meta do nosso site.
Changes to these files are typically done by the staff team. If you see something out of the ordinary we recommend you reach us in the [contributors chat room](https://chat.freecodecamp.org/channel/contributors).
Mudanças nesses arquivos são tipicamente feitos pelo time da staff. Se você vir algo fora do ordinário, nós recomendamos que você nos contate na [sala de chat dos contribuidores](https://chat.freecodecamp.org/channel/contributors).
## Testing the client app in a world language
## Testando o cliente web em um idioma mundial
You can test the client app in any language available in the [list of languages here](https://github.com/freeCodeCamp/freeCodeCamp/blob/6b4a6a02568b809fc216ea8566ff5df446d1da4e/config/i18n/all-langs.js#L5).
Você pode testar o client app em qualquer linguagem disponível nessa [lista de idiomas aqui](https://github.com/freeCodeCamp/freeCodeCamp/blob/6b4a6a02568b809fc216ea8566ff5df446d1da4e/config/i18n/all-langs.js#L5).
```js
const availableLangs = {
@ -90,19 +90,19 @@ You can test the client app in any language available in the [list of languages
};
```
If you are testing a new language, create a folder with the language name as the title next to the other languages and copy the JSON files from another language into your new folder.
Se você estiver testando um idioma novo, crie uma pasta com o nome do idioma como título próximo dos outros idiomas e copie os arquivos JSON de outro idioma para a sua pasta.
Add the language to the `client` array as seen above in the [`config/i18n/all-langs.js`](https://github.com/freeCodeCamp/freeCodeCamp/blob/main/config/i18n/all-langs.js) file.
Adicione o idioma para o array `client` como mostrado acima no arquivo [`config/i18n/all-langs.js`](https://github.com/freeCodeCamp/freeCodeCamp/blob/main/config/i18n/all-langs.js).
Next, follow the instructions in the comments in the same file to add/update the rest of the variables as needed.
A seguir, siga as instruções nos comentários dentro do mesmo arquivo para adicionar/atualizar o rest das variáveis se necessário.
Finally, set the `CLIENT_LOCALE` variable in your `.env` file to the locale you want to build and you're ready.
Finalmente, defina a variável `CLIENT_LOCALE` no seu arquivo `.env` para o local que você deseja fazer o build quando você estiver pronto(a).
## How to Structure Components
## Como estruturar os componentes
If you are working on a feature or a bug for the client web app, say for example adding new UI items on the settings page, you should follow the guidelines below. They will help you prepare the components for localization into all the supported world languages.
Se você estiver trabalhando em uma feature ou em um bug para o cliente web, por exemplo: adicionado novos itens de IU na pagina de configuração, você deve seguir as diretrizes abaixo. Elas vão te ajudar a preparar os componentes para tradução em todos os idiomas mundiais suportados.
### Functional Component
### Componente funcional
```js
import { useTranslation } from 'react-i18next';
@ -114,7 +114,7 @@ const { t } = useTranslation();
<p>{t('key')}</p>; // more details below
```
### Class Component
### Componente de classe
```js
import { withTranslation } from 'react-i18next';
@ -132,9 +132,9 @@ export default withTranslation()(Component);
export default connect(...)(withTranslation()(Component));
```
## Translate Using the "t" Function
## Traduza usando a função "t"
### Basic Translation
### Tradução básica
```js
// in the component:
@ -149,7 +149,7 @@ export default connect(...)(withTranslation()(Component));
<p>My paragraph</p>
```
### With Dynamic Data
### Com dados dinâmicos
```js
// in the component:
@ -166,13 +166,13 @@ const username = 'moT';
<p>Welcome moT</p>
```
The above example passes an object to the `t` function with a `username` variable. The variable will be used in the JSON value where `{{username}}` is.
O exemplo acima passa um objeto para a função `t` com uma variável `username`. A variável será usada no valor JSON onde `{{username}}` está.
## Translate with the `Trans` Component
## Traduza com o componente `Trans`
The general rule is to use the "t" function when you can. But there's a `Trans` component for when that isn't enough, usually when you have elements embedded in the text. You can use the `Trans` component with any type of react component.
A regra geral é usar a função "t" quando puder. Mas existe o componente `Trans` para quando isso não for o suficiente, geralmente quando você tem elementos embutidos no texto. Você pode usar o componente `Trans` com qualquer tipo de componente React.
### Basic Elements Nested
### Elementos básicos aninhados
```js
// in the component:
@ -193,11 +193,11 @@ import { Trans } from 'react-i18next'
<p>Welcome to <strong>freeCodeCamp</strong></p>
```
You can place the key inside the component tags like the above example if the text contains "simple" tags with no attributes. `br`, `strong`, `i`, and `p` are the default, but that list can be expanded in the i18n config.
Você pode colocar a chave dentro das tags do componente como no exemplo acima se o texto contém tags "simples" sem atributos. `br`, `strong`, `i` e `p` são padrões, mas essa lista pode ser expandida na configuração do i18n.
### Complex Elements Nested
### Elementos complexos aninhados
Other times, you will want to have certain text inside another element, an anchor tag is a good example:
Em outras situações, você vai querer ter um texto específico dentro de outro elemento, uma tag "a" é um bom exemplo:
```js
// in the component:
@ -216,9 +216,9 @@ Other times, you will want to have certain text inside another element, an ancho
<p>Check out <a href='https://forum.freecodecamp.org/'>our forum</a></p>
```
In the above example, the key is set in the attributes of the `Trans` component. The `<0>` and `</0>` in the JSON represent the first child of the component, in this case, the anchor element. If there were more children, they would just count up from there using the same syntax. You can find the children of a component in the react dev tools by inspecting it. `placeholder` is simply there because the linter complains about empty `<a>` elements.
No exemplo acima, a chave é definida nos atributos do componente `Trans`. O `<0>` e `</0>` no JSON representam o primeiro filho do componente, neste caso, o elemento âncora. Se há mais filhos, eles apenas vão se somar ali usando a mesma sintaxe. Você pode encontrar os filhos de um componente na ferramenta de desenvolvedor React fazendo uma inspeção. `placeholder` está ali pois o linter estava reclamando sobre um elemento `<a>` vazio.
### With a Variable
### Com uma variável
```js
// in the component:
@ -243,25 +243,25 @@ const email = 'team@freecodecamp.org';
<p>Send us an email at: <a href='mailto:team@freecodecamp.org'>team@freecodecamp.org</a><p>
```
In the above example, the key and a variable are set in the attributes of the `Trans` component. `{{ email }}` needs to be somewhere in the `Trans` component as well, it doesn't matter where.
No exemplo acima, a chave e a variável estão configuradas nos atributos do componente `Trans`. `{{ email }}` precisa estar em algum lugar no componente `Trans` também, não importa aonde.
## Changing Text
## Mudando texto
To change text on the client side of things, go to the relevant `.json` file, find the key that is being used in the React component, and change the value to the new text you want. You should search the codebase for that key to make sure it isn't being used elsewhere. Or, if it is, that the changes make sense in all places.
Para mudar o texto no lado do cliente, vá para o arquivo `.json`, ache a chave usada no componente React, e mude o valor para o novo texto que você deseja. Você deve pesquisar na base do código por aquela chave para ter certeza de que não está sendo usada em outro lugar. Ou, se está, se as mudanças fazem sentido em todos os lugares.
## Adding Text
## Adicionando texto
If the text you want to add to the client exists in the relevant `.json` file, use the existing key. Otherwise, create a new key.
Se o texto que você deseja adicionar ao cliente existe no arquivo `.json`, use a chave existente. Caso contrário, crie uma nova chave.
The English file is the "source of truth" for all of the `.json` files sharing the same name. If you need to add a new key, add it there. Then, add the key to **all** of the `translations.json` files.
O arquivo em inglês é a "fonte da verdade" para todos os arquivos `.json` que compartilham o mesmo nome. Se você precisa adicionar uma nova chave, a adicione lá. Então, adicione a chave em **todos** os arquivos `translations.json`.
> [!NOTE] Use English text for all languages if the file is translated through Crowdin. The tests will fail if you don't.
> [!NOTE] Use texto em inglês para todos os idiomas se o arquivo está sendo traduzido via Crowdin. Os testes vão falhar se você não fizer isso.
It would be nice to keep the keys in the same order across all the files as well. Also, try to put all punctuation, spacing, quotes, etc in the JSON files and not in the components or server files.
Seria bom manter as chaves na mesma ordem entre todos os arquivos também. Além disso, tente colocar toda a pontuação, espaçamento, citações e tudo mais nos arquivos JSON, não nos componentes ou arquivos de servidor.
> [!NOTE] The underscore (`_`) is a reserved character for keys in the client side files. See [the documentation](https://www.i18next.com/translation-function/plurals) for how they are used.
> [!NOTE] O underscore (`_`) é um caractere reservado para chaves dos arquivos que ficam do lado do cliente. Veja [a documentação](https://www.i18next.com/translation-function/plurals) para saber como são usados.
## Helpful Documentation
## Documentação útil
- [react-i18next docs](https://react.i18next.com/latest/usetranslation-hook)
- [i18next docs](https://www.i18next.com/translation-function/essentials)
- [documentação react-i18next](https://react.i18next.com/latest/usetranslation-hook)
- [documentação i18next](https://www.i18next.com/translation-function/essentials)

80
docs/i18n/portuguese/how-to-work-on-practice-projects.md
View File

@ -1,78 +1,78 @@
# How to Work on Practice Projects
# Como trabalhar em projetos práticos
The `tools/challenge-helper-scripts` folder contains tools to help facilitate the creation and maintenance of the freeCodeCamp project-based curriculum.
A pasta `tools/challenge-helper-scripts` contém ferramentas para ajudar a facilitar a criação e a manutenção dos projetos baseados no currículo do freeCodeCamp.
## Create a new project
## Criando um novo projeto
Run `npm run create-project`. This opens up a command line ui that guides you through the process. Once that has finished, there should be a new challenge in the English curriculum that you can use for the first step of the project. For example, if you created a project called `test-project` in the Responsive Web Design certification, it would be in `curriculum/challenges/english/01-responsive-web-design/test-project`.
Execute `npm run create-project`. Esse comando abrirá uma interface de linha de comando que vai guiar você através do processo. Uma vez que tiver terminado, deverá aparecer um novo desafio no currículo inglês que você pode usar para começar o projeto. Por exemplo, se você tiver criado um projeto chamado `test-project` na certificação de Design responsivo para a web, ele estará em `curriculum/challenges/english/01-responsive-web-design/test-project`.
If you want to create new steps, the following tools simplify that process.
Se você quer criar novos passos, as ferramentas a seguir vão simplificar o processo.
## create-next-step
## create-next-step (criar próximo passo)
A one-off script that will automatically add the next step based on the last step numbered as `part-xxx.md` where `xxx` represents the 3-digit step number of the last step. The challenge seed code will use the previous step's challenge seed code with the editable region markers (ERMs) removed.
Um script único que automaticamente adiciona um novo passo baseado no último passo numerado como `part-xxx.md` onde `xxx` representa o número de 3 dígitos do último passo. O código inicial de desafio usará o código inicial de desafio da etapa anterior com os marcadores de região editáveis ​​(ERMs) removidos.
**Note:** This script also runs [reorder-steps](how-to-work-on-practice-projects#reorder-steps).
**Observação:** Esse script também executa [reorder-steps](how-to-work-on-practice-projects#reorder-steps).
### How to run script:
### Como executar esse script:
1. Change to the directory of the project.
2. Run the following npm command:
1. Mude para o diretório do projeto.
2. Execute o comando npm a seguir:
```bash
npm run create-next-step
```
## create-empty-steps
## create-empty-steps (criar passos vazios)
A one-off script that automatically adds a specified number of steps at a specific starting step number. The challenge seed code for all steps created will be empty.
Um script único que adiciona automaticamente um número especificado de passos começando a partir de um número específico. O código seed de todos os passos criados estarão vazios.
**Note:** This script also runs [reorder-steps](how-to-work-on-practice-projects#reorder-steps).
**Observação:** Esse script também executa [reorder-steps](how-to-work-on-practice-projects#reorder-steps).
### How to run script:
### Como executar esse script:
1. Change to the directory of the project.
2. Run the following npm command:
1. Mude para o diretório do projeto.
2. Execute o comando npm a seguir:
```bash
npm run create-empty-steps start=X num=Y # where X is the starting step number and Y is the number of steps to create.
npm run create-empty-steps start=X num=Y # onde X é o número do passo onde deve iniciar e Y é o número de passos que deverão ser criados.
```
## create-step-between
A one-off script that automatically adds a new step between two existing consecutive steps. The challenge seed code will use the existing starting step's challenge seed code with the editable region markers (ERMs) removed.
Um único script que automaticamente adiciona passos entre dois passos consecutivos. O código inicial do desafio usará o código inicial do desafio da etapa inicial existente com os marcadores de região editáveis ​​(ERMs) removidos.
**Note:** This script also runs [reorder-steps](how-to-work-on-practice-projects#reorder-steps).
**Observação:** Esse script também executa [reorder-steps](how-to-work-on-practice-projects#reorder-steps).
### How to run script:
### Como executar esse script:
1. Change to the directory of the project.
2. Run the following npm command:
1. Mude para o diretório do projeto.
2. Execute o comando npm a seguir:
```bash
npm run create-step-between start=X # where X is the starting step number
npm run create-step-between start=X # onde X é o número do passo para começar
```
## delete-step
A one-off script that deletes an existing step and then reorders the remaining step files in the project's folder as well as updates the `challengeOrder` property array in the project's `meta.json` with the new order of the steps.
Um único script que deleta um passo existente e reordena os passos que restaram na pasta do projeto e também atualiza a propriedade do array `challengeOrder` no `meta.json` do projeto com a nova ordem dos passos.
### How to run script
### Como executar esse script
1. Change to the directory of the project.
2. Run the following npm command:
1. Mude para o diretório do projeto.
2. Execute o comando npm a seguir:
```bash
npm run delete-step num=x # where x is the step number to be deleted.
npm run delete-step num=x # onde x é o número do passo a ser deletado.
```
## reorder-steps
A one-off script that automatically reorders the step files in a project's markdown files based on the filename. It also updates the `challengeOrder` property array in the project's `meta.json` with the new order of the steps.
Um script único que automaticamente reordena os aquivos de passos em arquivos markdown do projeto baseado no nome dos arquivos. Também atualiza a propriedade do array `challengeOrder` no `meta.json` do projeto com a nova ordem dos passos.
### Working Example
### Exemplo de trabalho
Let's say you start with the following project structure:
Digamos que você começa com a estrutura de projeto a seguir:
```bash
part-1.md
@ -83,9 +83,9 @@ part-5.md
part-6.md
```
At some point you decide you need to delete `part-2.md`, because that step is no longer needed. Also, you decide to break down `part-4.md` into three steps instead of just one.
Em algum momento, você decide que precisa deletar `part-2.md`, porque os passos nele não são mais necessários. Você também decide que vai diluir as partes dentro de `part-4.md` em três passos ao invés de um.
To accomplish this restructure, you would need to delete `part-2.md` and then add a `part-4a.md` and a `part-5b.md`. The new folder structure would look like the following:
Para completar essa reestruturação, você precisará deletar `part-2.md` e então adicionar a `part-4a.md` e a `part-5b.md`. A nova estrutura da pasta deve ficar assim:
```bash
part-001.md
@ -97,9 +97,9 @@ part-005.md
part-006.md
```
You now need the file names to be `part-1.md` through `part-7.md`, because you removed one but gained two more for a net difference of one file. Also, the frontmatter of each file below a deleted step or added step will need to be modified by making the `title` key value match the new step number. For example, after renaming `part-3.md` to `part-2.md`, you would need to change `part-2.md`'s title from `Part 03` to `Part 02`.
Você precisa agora que os nomes dos arquivos sejam `part-1.md` a `part-7.md`, porque você removeu um, mas ganhou dois arquivos novos, assim gerando somente um arquivo novo. Além disso, o frontmatter de cada arquivo abaixo de um passo adicionado ou excluído precisará ser modificado, onde o valor chave do `title` tem que ser igual ao novo número do passo. Por exemplo, depois de renomeaer `part-3.md` para `part-2.md`, você precisará alterar o título do `part-2.md` de `Part 03` para `Part 02`.
See below for the actual project folder changes needed:
Veja abaixo as mudanças necessárias na pasta do projeto:
```bash
part-001.md
@ -111,12 +111,12 @@ part-005.md renames to part-006.md and title changes to "Part 6"
part-006.md renames to part-007.md and title changes to "Part 7"
```
Along with the above changes, the `challengeOrder` key in the project's `meta.json` file needs to reflect the new step order. This is needed because each step below a step deletion and/or step addition changes the `title` associated with each of the affected step's challenge `id`.
Junto com as mudanças acima, a chave `challengeOrder` no arquivo `meta.json` do projeto precisará refletir a nova ordem dos passos. Isso é necessário porque cada etapa abaixo de uma exclusão de etapa e/ou adição de etapa altera o `title` associado a cada um dos `id` do desafio da etapa afetada.
### How to run script
### Como executar esse script
1. Change to the directory of the project.
2. Run the following npm command:
1. Mude para o diretório do projeto.
2. Execute o comando npm a seguir:
```bash
npm run reorder-steps

58
docs/i18n/portuguese/how-to-work-on-the-news-theme.md
View File

@ -1,29 +1,29 @@
# Como trabalhar no tema de notícias de desenvolvedor do freeCodeCamp.org
As notícias de desenvolvimento, também conhecidas como o site de [`/news`](https://www.freecodecamp.org/news), são fornecidas por [Ghost](https://ghost.org/). We use a custom theme for the look and feel of the site. The source code of the theme is available here: <https://github.com/freeCodeCamp/news-theme>.
As notícias de desenvolvimento, também conhecidas como o site de [`/news`](https://www.freecodecamp.org/news), são fornecidas por [Ghost](https://ghost.org/). Usamos um tema personalizado para a aparência do site. O código fonte do tema está disponível aqui: <https://github.com/freeCodeCamp/news-theme>.
## The Theme
## O tema
Ghost uses a simple templating language called [Handlebars](http://handlebarsjs.com/) for its themes. O tema usado em `/news` é baseado no [tema casper](https://github.com/TryGhost/Casper) padrão.
Ghost usa uma linguagem simples de template chamada [Handlebars](http://handlebarsjs.com/) para seus temas. O tema usado em `/news` é baseado no [tema casper](https://github.com/TryGhost/Casper) padrão.
The default theme is commented pretty heavily so that it should be fairly easy to work out what's going on just by reading the code and the comments. Quando você se sentir confortável com a forma como tudo lá funciona, Ghost também tem uma [documentação da API de tema](https://themes.ghost.org) completa que explica cada helper e template do Handlebars possível.
O tema padrão é bastante comentado então deve ser razoavelmente fácil resolver o que for preciso apenas lendo o código e os comentários. Quando você se sentir confortável com a forma como tudo lá funciona, Ghost também tem uma [documentação da API de tema](https://themes.ghost.org) completa que explica cada helper e template do Handlebars possível.
**The main files are:**
**Os arquivos principais são:**
- `default.hbs` - The main template file
- `index.hbs` - Used for the home page
- `post.hbs` - Used for individual posts
- `page.hbs` - Used for individual pages
- `tag.hbs` - Used for tag archives
- `default.hbs` - O arquivo de template principal
- `index.hbs` - Usado para a página inicial
- `post.hbs` - Usado para postagens individuais
- `page.hbs` - Usado para páginas individuais
- `tag.hbs` - Usado para arquivos de tags
- `author.hbs` - Usado para arquivamentos de autor
Um truque muito legal é que você também pode criar modelos personalizados únicos, apenas adicionando o slug de uma página a um arquivo de modelo. For example:
Um truque muito legal é que você também pode criar modelos personalizados únicos, apenas adicionando o slug de uma página a um arquivo de modelo. Por exemplo:
- `page-about.hbs` - Custom template for the `/about/` page
- `page-about.hbs` - Modelo personalizado para a página `/about/`
- `tag-news.hbs` - Modelo personalizado para o arquivo `/tag/news/`
- `author-ali.hbs` - Modelo personalizado para o arquivo `/author/ali/`
## Development
## Desenvolvimento
1. Instale o Ghost localmente.
@ -40,7 +40,7 @@ Um truque muito legal é que você também pode criar modelos personalizados ún
> Observação: atualmente, o freeCodeCamp usa a versão `2.9.0` do Ghost. Então, certifique-se de estar usando uma versão maior que essa.
Certifique-se de executar comandos `ghost` do diretório `ghost-local-site`. Follow additional instructions on [Ghost's official documentation](https://docs.ghost.org) if are not familiar with its interface.
Certifique-se de executar comandos `ghost` do diretório `ghost-local-site`. Siga instruções adicionais na [documentação oficial do Ghost](https://docs.ghost.org) se não estiver familiarizado com a interface.
2. Faça fork e clone o repositório no seu diretório tema (substituindo `YOUR_USERNAME` com seu nome de usuário do GitHub):
@ -49,11 +49,11 @@ Um truque muito legal é que você também pode criar modelos personalizados ún
git clone https://github.com/YOUR_USERNAME/news-theme.git
```
3. Make sure you have all the pre-requisites.
3. Certifique-se de que você tem todos os pré-requisitos.
The theme styles are compiled using Gulp/PostCSS to polyfill future CSS spec. You'll need [Node.js](https://nodejs.org/). Certifique-se de que sua versão do Node.js é compatível com o `ghost`.
Os estilos do tema são compilados utilizando Gulp/PostCSS para poliencher as especificações CSS futuras. Você precisará do [Node.js](https://nodejs.org/). Certifique-se de que sua versão do Node.js é compatível com o `ghost`.
4. Install dependencies and develop the theme
4. Instale as dependências e desenvolva o tema
```sh
npm ci
@ -62,38 +62,38 @@ Um truque muito legal é que você também pode criar modelos personalizados ún
5. Agora você pode editar os arquivos `/assets/css/`, que serão compilados automaticamente para `/assets/built/`.
6. Access the development site.
6. Acessar o site de desenvolvimento.
a. Digite `http://localhost:2368/ghost/` na sua barra de pesquisa. Continue com a configuração solicitada na página (se estiver executando ghost pela primeira vez).
b. _(One-time only, during setup)_ Restart Ghost, on a separate terminal once to ensure the theme is available.
b. _(Apenas uma vez, durante a configuração)_ Reinicie o Ghost, em um terminal separado para garantir que o tema esteja disponível.
```sh
cd ghost-local-site
ghost restart
```
c. _(One-time only, during setup)_ Once you've done this, go to `http://localhost:2368/ghost/#/settings/design` and scroll to the bottom. Make sure you click activate on the `freecodecamp-news-theme`.
c. _(Apenas uma vez, durante a configuração)_ Uma vez que você tenha feito isso, vá até `http://localhost:2368/ghost/#/settings/design` e role para baixo. Certifique-se de clicar em ativar no `freecodecamp-news-theme`.
7. Faça um zip do código final e faça um pull-request
O `zip` do Gulp task empacota os arquivos de tema em `dist/<theme-name>.zip`, que podemos carregar no site de produção.
When you make a PR, please make sure you have run the below script prior to commiting the code and sending a PR.
Quando você criar uma PR, por favor certifique-se de ter executado o script abaixo antes de confirmar o código e enviar uma PR.
```sh
npm run zip
```
## Other Reference and resources
## Outras Referências e recursos
### PostCSS Features Used
### Características do PostCSS utilizadas
- Autoprefixer - Don't worry about writing browser prefixes of any kind, it's all done automatically with support for the latest 2 major versions of every browser.
- Variables - Simple pure CSS variables
- [Color Function](https://github.com/postcss/postcss-color-function)
- Autoprefixer - Não se preocupe em escrever os prefixos do navegador de qualquer tipo, tudo é feito automaticamente com suporte para as 2 versões principais mais recentes de cada navegador.
- Variáveis - Variáveis CSS simples
- [Função de Cor](https://github.com/postcss/postcss-color-function)
### SVG Icons
### Ícones SVG
The theme uses inline SVG icons, included via Handlebars partials. You can find all icons inside `/partials/icons`. To use an icon just include the name of the relevant file, eg. To include the SVG icon in `/partials/icons/rss.hbs` - use `{{> "icons/rss"}}`.
O tema usa ícones SVG embutidos, incluídos via partial Handlebars. Você pode encontrar todos os ícones dentro de `/partials/icons`. Para usar um ícone, inclua o nome do arquivo relevante, por exemplo. Para incluir o ícone SVG em `/partials/icons/rss.hbs` - use `{{> "icons/rss"}}`.
You can add your own SVG icons in the same manner.
Você pode adicionar seus próprios ícones SVG da mesma maneira.