├── .gitbook
└── assets
│ ├── asking-pull-request.png
│ ├── create-pull-request.png
│ ├── create-repository-button.png
│ ├── create-repository-desc.png
│ ├── create-repository-name.png
│ ├── create-repository-public-private.png
│ ├── differents-commits.png
│ ├── image.png
│ ├── initialize-with-readme.png
│ ├── repo-create.png
│ ├── screen-shot-2018-09-22-at-20.22.57.png
│ └── screen-shot-2018-09-22-at-22.51.11.png
├── CONTRIBUTING.md
├── README.md
├── SUMMARY.md
├── ciclo-de-vida-basico
├── comandos-mais-utilizados.md
├── criando-um-repositorio.md
├── hands-on-2.md
├── o-que-e-o-.gitignore.md
└── trabalhando-com-branchs.md
├── dicas-boas-praticas
├── dicas-de-boas-praticas.md
├── explicacao-sobre-cherry-pick.md
├── explicacao-sobre-rebase.md
└── explicacao-sobre-squash.md
├── git-e-github
├── conceitos-e-vocabulario-do-git.md
├── setup-de-instalacao.md
├── setup-instalacao-linux.md
├── setup-instalacao-windows.md
└── setup.md
├── hands-on
├── exercicio-1.md
├── exercicio-2.md
├── exercicio-3.md
└── exercicio-4.md
├── images
├── alternate-between-branches.png
├── create-branches-1.png
├── create-branches-2.png
├── git-remote-v.png
├── hands-on-fork-1.PNG
├── hands-on-fork-2.PNG
├── hands-on-fork-3.PNG
├── hands-on-fork.PNG
├── hands-on-merge.png
├── p0001-0.png
├── p0001-1.png
├── p0001-10.png
├── p0001-11.png
├── p0001-12.png
├── p0001-13.png
├── p0001-14.png
├── p0001-2.png
├── p0001-3.png
├── p0001-4.png
├── p0001-5.png
├── p0001-6.png
├── p0001-7.png
├── p0001-8.png
└── p0001-9.png
└── o-que-onde-e-por-que.md
/.gitbook/assets/asking-pull-request.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/asking-pull-request.png
--------------------------------------------------------------------------------
/.gitbook/assets/create-pull-request.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/create-pull-request.png
--------------------------------------------------------------------------------
/.gitbook/assets/create-repository-button.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/create-repository-button.png
--------------------------------------------------------------------------------
/.gitbook/assets/create-repository-desc.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/create-repository-desc.png
--------------------------------------------------------------------------------
/.gitbook/assets/create-repository-name.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/create-repository-name.png
--------------------------------------------------------------------------------
/.gitbook/assets/create-repository-public-private.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/create-repository-public-private.png
--------------------------------------------------------------------------------
/.gitbook/assets/differents-commits.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/differents-commits.png
--------------------------------------------------------------------------------
/.gitbook/assets/image.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/image.png
--------------------------------------------------------------------------------
/.gitbook/assets/initialize-with-readme.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/initialize-with-readme.png
--------------------------------------------------------------------------------
/.gitbook/assets/repo-create.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/repo-create.png
--------------------------------------------------------------------------------
/.gitbook/assets/screen-shot-2018-09-22-at-20.22.57.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/screen-shot-2018-09-22-at-20.22.57.png
--------------------------------------------------------------------------------
/.gitbook/assets/screen-shot-2018-09-22-at-22.51.11.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/.gitbook/assets/screen-shot-2018-09-22-at-22.51.11.png
--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | ## Como contribuir com esse repositório?
2 |
3 | Estamos atualizando o conteúdo desse guia de git e github e a ajuda da comunidade será essencial para isso!!
4 |
5 | ## Com quais assuntos posso contribuir?
6 | Você pode ver quais assuntos e exercícios estamos buscando contribuição nas [issues](https://github.com/WoMakersCode/git-e-github/issues) do nosso projeto.
7 |
8 | ### :question: Como envio um conteúdo para esse guia?
9 | Para enviar um conteúdo, siga os seguintes passos:
10 | 1. :fork_and_knife: Faça uma fork deste repositório
11 | 2. :hammer: Veja a issues abertas no repositório, as issues terão a estrutura [seção](assunto da issue)
12 | *as seções são as pastas com os conteúdos, atualmente as seções se dividem em: [ciclo de vida basico](https://github.com/WoMakersCode/git-e-github/tree/master/ciclo-de-vida-basico),[git e github](https://github.com/WoMakersCode/git-e-github/tree/master/git-e-github),[hands-on](https://github.com/WoMakersCode/git-e-github/tree/master/hands-on) e [dicas-boas-praticas](https://github.com/WoMakersCode/git-e-github/tree/master/dicas-boas-praticas)*
13 | 3. :busts_in_silhouette: Adicione o seu perfil na área de pessoas colaboradoras do projeto (contributors)
14 | 4. :wrench: Envie um Pull Request
15 | 5. :wrench: Solicite a revisão do hacktober-team
16 | 6. :tada: Tenha o seu Pull Request aprovado - sucesso!
17 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ---
2 | description: >-
3 | Este é um curso rápido e prático para você aprender a utilizar controle de
4 | versão em seus projetos.
5 | ---
6 |
7 | # Desvendando Git e GitHub
8 |
9 | 
10 |
11 | ## **GitHub** é como as pessoas constroem software
12 |
13 | Trabalhar com controle de versão é uma habilidade essencial para qualquer desenvolvedora de software gerenciar sua base de código, acompanhar as alterações e coordenar a colaboração entre uma equipe.
14 |
15 | Neste curso, você aprenderá sobre:
16 |
17 | 1. [Criando uma conta e seu primeiro repositório no GitHub](git-e-github/setup.md)
18 | 2. [Setup de instalação](git-e-github/setup-de-instalacao.md)
19 | 3. [Vocabulário](git-e-github/conceitos-e-vocabulario-do-git.md)
20 | 4. [Trabalhando com repositórios](ciclo-de-vida-basico/criando-um-repositorio.md)
21 | 5. [Comandos mais utilizados](ciclo-de-vida-basico/comandos-mais-utilizados.md)
22 | 6. [Trabalhando com branchs](ciclo-de-vida-basico/trabalhando-com-branchs.md)
23 | 7. [Restringindo arquivos com .gitignore](ciclo-de-vida-basico/o-que-e-o-.gitignore.md)
24 | 8. [Dicas de boas práticas](dicas-boas-praticas/dicas-de-boas-praticas.md)
25 | 9. [Atividades hands-on](ciclo-de-vida-basico/hands-on-1.md)
26 |
27 |
28 | ## **Sobre a nossa comunidade**
29 |
30 | A WoMakersCode é uma **comunidade** sem fins lucrativos, que busca o **protagonismo feminino na tecnologia**, através do desenvolvimento profissional e econômico. Oferecemos workshops, eventos e debates com foco no mercado de Tecnologia, orientados para capacitação técnica e fortalecimento de habilidades pessoais. Nossos eventos são realizados em diversas cidades do país, promovendo a conscientização da igualdade de gênero e buscando compreender as causas da sub-representação feminina neste mercado de TI.
31 |
32 |
33 | ## **Contribua para esse guia**
34 | Veja detalhes no nosso [guia de contribuição](https://github.com/WoMakersCode/git-e-github/blob/master/CONTRIBUTING.md)
35 |
36 | ## **Quem já contribuiu com esse guia**
37 |
38 | [Cynthia Zanoni](https://github.com/cyz)
39 | [Kamila Santos](https://github.com/Kamilahsantos)
40 | [Caroline Pinheiro](https://github.com/CarolPinheiro)
41 | [Leticia Campos](https://github.com/leticiacamposs2)
42 | [Ester Gama](https://github.com/esterfania)
43 | [Letícia Vargas](https://github.com/leticiavargas)
44 | [Danielle Farias](https://github.com/danielle8farias/)
45 |
46 | **Acompanhe nossos canais e ajude-nos a crescer:**
47 |
48 | **→** [**Participe de nossos Meetups** ](https://www.meetup.com/pt-BR/WoMakersCode/) **→** [**Conheça nosso portal**](http://womakerscode.org/)\*\*\*\*
49 |
50 | **→ Siga em:** [**Facebook**](https://www.facebook.com/womakerscode/) **//** [**Twitter**](https://twitter.com/womakerscode) **//** [**Instagram**](https://www.instagram.com/womakersgram/) **//** [**Youtube**](https://www.youtube.com/womakerscode)\*\*\*\*
51 |
52 |
--------------------------------------------------------------------------------
/SUMMARY.md:
--------------------------------------------------------------------------------
1 | # Table of contents
2 |
3 | * [Desvendando Git e GitHub](README.md)
4 | * [O que é, o que é?](o-que-onde-e-por-que.md)
5 |
6 | ## Git e GitHub
7 |
8 | * [Criando uma conta e seu primeiro repositório no GitHub](git-e-github/setup.md)
9 | * [Setup de Instalação](git-e-github/setup-de-instalacao.md)
10 | * [Vocabulário do Git](git-e-github/conceitos-e-vocabulario-do-git.md)
11 |
12 | ## Ciclo de vida básico
13 |
14 | * [Trabalhando com Repositórios](ciclo-de-vida-basico/criando-um-repositorio.md)
15 | * [Comandos mais utilizados](ciclo-de-vida-basico/comandos-mais-utilizados.md)
16 | * [Hands-on \#1](ciclo-de-vida-basico/hands-on-1.md)
17 | * [Trabalhando com branchs](ciclo-de-vida-basico/trabalhando-com-branchs.md)
18 | * [O que é o .gitignore?](ciclo-de-vida-basico/o-que-e-o-.gitignore.md)
19 | * [Hands-on \#2](ciclo-de-vida-basico/hands-on-2.md)
20 |
21 | ## Hands on
22 |
23 | * [Exercício 1](hands-on/exercicio-1.md)
24 | * [Exercício 2](hands-on/exercicio-2.md)
25 | * [Exercício 3](hands-on/exercicio-3.md)
26 |
27 | ## Dicas e boas práticas
28 |
29 | * [Dicas de boas práticas](dicas-boas-praticas/dicas-de-boas-praticas.md)
30 | * [Explicação sobre rebase](dicas-boas-praticas/explicação-sobre-rebase.md)
31 | * [Explicação sobre squash](dicas-boas-praticas/explicação-sobre-squash.md)
32 | * [Explicação sobre cherry pick](dicas-boas-praticas/explicação-sobre-cherry-pick.md)
33 |
--------------------------------------------------------------------------------
/ciclo-de-vida-basico/comandos-mais-utilizados.md:
--------------------------------------------------------------------------------
1 | # Comandos mais utilizados
2 |
3 | ## git status
4 |
5 | Verifica o status/condição da branch em que você está trabalhando, arquivos modificados, criados e exluídos
6 |
7 | ```css
8 | $ git status
9 | ```
10 |
11 | ## git add
12 |
13 | Após criar um arquivo, adicione o arquivo no rastreamento do Git. No Terminal, use o comando `git add` seguido do nome do arquivo ou somente `.` para adicionar todos os arquivos ainda não rastreados.
14 |
15 | ```css
16 | $ git add index.html
17 | ```
18 |
19 | ## git commit
20 |
21 | Depois de adicionar o arquivo a ser rastreado, confirme as alterações a serem rastreadas usando o Git. No Terminal, use `git commit - m` seguido por uma mensagem curta para confirmar as mudanças.
22 |
23 | ```css
24 | $ git commit -m "commit inicial"
25 | ```
26 |
27 | Dica: tente tornar suas mensagens curtas, mas significativas.
28 |
29 | #### Exemplo
30 |
31 | ```css
32 | $ git commit -m "Página inicial e pastas de CSS e JS"
33 | ```
34 |
35 | ## git push
36 |
37 | Depois de confirmar as alterações, envie as alterações de sua máquina local para o repositório remoto. No Terminal, use o comando `git push` seguido do nome da branch que você está enviando.
38 |
39 | #### Exemplo
40 |
41 | ```css
42 | $ git push origin master
43 | ```
44 |
45 |
46 |
47 |
--------------------------------------------------------------------------------
/ciclo-de-vida-basico/criando-um-repositorio.md:
--------------------------------------------------------------------------------
1 | # Trabalhando com Repositórios
2 |
3 | ## Criar um repositório
4 |
5 | É possível versionar um projeto através de um repositório, que em seu computador, basicamente, será uma pasta que terá todos os arquivos do seu projeto.
6 |
7 | ```css
8 | $ git init
9 | ```
10 |
11 | Este comando, irá criar uma pasta `.git` na raiz do projeto e nela, ficarão registradas as informações relacionadas ao controle do versionamento.
12 |
13 | ## Conectar um repositório local com a nuvem do GitHub
14 |
15 | Se você já está trabalhando em um projeto que ainda não está versionado, você pode criar um repositório no GitHub e conectar seus arquivos locais com o GitHub. Para adicionar o rastreamento remoto, use o comando `git remote add` no terminal, no diretório em que seu repositório está armazenado.
16 |
17 | ```javascript
18 | /* navegando até a pasta */
19 | $ cd nomedaminhapasta
20 |
21 | /* estando dentro da pasta do projeto, indique a URL */
22 | $ git remote add origin https://github.com/user/repo.git
23 |
24 | /* verificando a origem adicionada ao repositório */
25 | $ git remote -v
26 |
27 | /* Retorno esperado */
28 | origin https://github.com/user/repo.git (fetch)
29 | origin https://github.com/user/repo.git (push)
30 | ```
31 |
32 | ## Clonar um repositório já existente
33 |
34 | Clonar um repositório já existente é, literalmente, fazer uma cópia dele em sua máquina local. No caso a seguir, vamos clonar um repositório remoto \(que está na nuvem do GitHub\).
35 |
36 | 1. Na página da Web do [repositório](https://github.com/WoMakersCode/Front-end-Study-Group), clique no botão verde "clone or download", no lado direito da página.
37 |
38 | 
39 |
40 | 2. Selecione a opção "Usar HTTPS" - se estiver disponível - e copie o link.
41 |
42 | 3. No Terminal, navegue até sua pasta de desenvolvimento.
43 |
44 | *Nota: Se você não tiver uma pasta de desenvolvimento, pode ser uma boa idéia criar uma onde você pode armazenar todos os diretórios rastreados pelo `git` em um só lugar.*
45 |
46 | No tutorial, vou navegar até minha área de trabalho \(Desktop\) e criar uma pasta nova, no momento que estiver clonando o repositório. Para isso, logo após a URL do repositório no GitHub, vou adicionar o nome da pasta.
47 |
48 | ```css
49 | $ cd Desktop
50 | $ git clone https://github.com/WoMakersCode/Front-end-Study-Group.git nomedanovapasta
51 | ```
52 |
53 |
54 |
55 |
--------------------------------------------------------------------------------
/ciclo-de-vida-basico/hands-on-2.md:
--------------------------------------------------------------------------------
1 | # Hands-on: Como fazer um fork e contribuir com outros projetos
2 |
3 | Um fork do GitHub é uma cópia de um repositório (repo) que fica em sua conta. Depois de fazer um fork (bifurcar) de um repositório, você poderá editar o conteúdo de seu repositório bifurcado sem afetar o repositório principal. Quando desejar, poderá enviar suas alterações para o repositório principal.
4 |
5 | ## Criando o fork
6 |
7 | Supondo que você esteja usando o GitHub, essa etapa é fácil. Apenas encontre o repositório para o qual você está contribuindo e pressione o botão Fork no canto superior direito. Isso criará uma cópia exata do repositório (e todos os seus ramos) com seu próprio nome de usuário.
8 |
9 | 
10 |
11 | ## Clonando o repositório bifurcado
12 |
13 | O GitHub o redirecionará automaticamente para o repositório bifurcado com o seu nome de usuário. Este é o repositório que você precisa para clonar em seu ambiente de desenvolvimento local, não o original. Pegue a URL fornecida pelo GitHub no botão verde "Clonar ou Baixar" e conecte-a ao comando abaixo.
14 |
15 | 
16 |
17 | ```
18 | git clone https://github.com/cyz/data-science-bootcamp.git
19 | ```
20 |
21 | ## Mantendo seu repositório bifurcado com o repositório principal
22 |
23 | Depois de fazer o fork de um repositório, as alterações no repositório original (ou "upstream") não são enviadas para o seu fork. Precisamos dizer ao novo repositório para seguir as mudanças feitas no upstream para mantê-lo atualizado por meio de controles remotos.
24 |
25 | Alterne os diretórios para o repositório bifurcado que você acabou de clonar e execute os seguintes comandos. Substitua a última parte da primeira linha pelo URL do clone do repositório **original** - semelhante ao modo como você pegou o URL na etapa 2, mas **não é** aquele com seu nome de usuário.
26 |
27 | Isso vincula a bifurcação de volta ao repositório original como um remoto, que nomearemos ``upstream``, depois o buscaremos.
28 |
29 | ```
30 | git remote add --track master upstream https://github.com/WoMakersCode/data-science-bootcamp.git
31 | git fetch upstream
32 | ```
33 |
34 | ## Criando uma nova branch para realizar mudanças
35 |
36 | É possível fazer alterações diretamente na branch `master`, mas isso pode FUBAR as coisas no futuro por motivos complicados. É melhor criar um `checkout` novo ramo para **cada** mudança / melhoria que você deseja fazer. Substitua `fix-readme-typo` por um nome mais descritivo para suas alterações, como `add-study-references` ou `update-dependencies`.
37 |
38 | ```
39 | git checkout -b fix-readme-typo upstream/master
40 | ```
41 |
42 | ## Faça suas alterações!
43 |
44 | Essa é a parte mais fácil ou a mais difícil, dependendo de como você a encara. 😉 Neste ponto, você está isolado no novo branch que acabou de criar e é seguro abrir qualquer editor de texto ou IDE que usar e enlouquecer.
45 |
46 | ## Adicione, confirme e envie as alterações
47 |
48 | Você provavelmente está acostumado com esses comandos. Adicione os arquivos que você alterou e envie-os com uma mensagem descritiva.
49 |
50 | ```
51 | git add .
52 | git commit -m "Ajustando alguns erros gramaticais no arquivo readme"
53 | ```
54 |
55 | A única diferença é o ramo para o qual você está empurrando. Você provavelmente costuma enviar `push` para master, mas, neste caso, estamos enviando para o branch com o nome que você criou na etapa 4.
56 |
57 | ```
58 | git push -u origin fix-readme-typo
59 | ```
60 |
61 | ## Criando o seu Pull Request (PR)
62 |
63 | Agora você está pronto para enviar a melhoria feita aos mantenedores do projeto para aprovação. Ao acessar o seu repositório bifurcado em sua conta, você irá encontrar um aviso de que há uma branch disponível para Pull Request.
64 |
65 | 
66 |
67 | Vá para a guia Pull Requests do repositório original e você verá uma sugestão automática do GitHub para criar uma solicitação pull de seu novo branch.
68 |
69 | 
70 |
--------------------------------------------------------------------------------
/ciclo-de-vida-basico/o-que-e-o-.gitignore.md:
--------------------------------------------------------------------------------
1 | # O que é o .gitignore?
2 |
3 | Às vezes, há arquivos sensíveis \(exemplo: senhas\) ou que são irrelevantes e que você não deseja versionar \(exemplo: node\_module\).
4 |
5 | O Git usa um arquivo oculto chamado `.gitignore` para indicar quais arquivos ou tipos de arquivos \(exemplo: _.pkl, .ipynb\_checkpoints_\) não devem ser rastreados para o versionamento. Depois de adicionar o(s) nome(s) do(s) arquivo(s) ao arquivo `.gitignore`, as alterações feitas nos arquivos que correspondem a esses nomes não serão rastreadas.
6 |
7 | Exemplo:
8 |
9 | * Crie um arquivo chamado "credentials.json" no diretório do seu repositório.
10 | * Se você executar o `git status`, deverá ver "credentials.json" na seção de arquivos não acompanhados.
11 | * Agora, crie um arquivo chamado `.gitignore` - se ele não existir.
12 | * Adicione o texto "credentials.json" ao arquivo `.gitignore`
13 | * Salve e feche o arquivo `.gitignore`
14 | * Se você executar o `git status`, "credentials.json" não deverá mais aparecer.
15 |
16 | É uma boa prática adicionar, definir as regras e enviar o arquivo `.gitignore` para o GitHub, para que seus colaboradores possam ver \(e adicionar\) quais arquivos não devem ser rastreados no repositório.
17 |
18 |
--------------------------------------------------------------------------------
/ciclo-de-vida-basico/trabalhando-com-branchs.md:
--------------------------------------------------------------------------------
1 | # Trabalhando com branchs
2 |
3 | ## 1. O que é uma branch?
4 |
5 | Acho que, sem sombra de dúvidas, quando começamos a mexer com github essa é a primeira dúvida que vem à nossa mente. Afinal, o que são as famosas branches que todos falam?
6 | Para explicar isso, eu gostaria de usar um exemplo mais prático, misturado com algo visual.
7 | Quando pesquisamos no google o que são branches, a primeira imagem que nos aparece é essa daqui:
8 | 
9 | E se você nunca teve contato anteriormente com isso, pode ser meio assustador, mas não se preocupe, é mais fácil do que parece.
10 | Branch, é o nome dado para o sistema de versionamento que usamos através do Git e Github, para manter controle dos projetos.
11 | Vamos supor que estivéssemos construindo uma calculadora juntos, e decidíssemos que você cuidaria de criar a operação de soma e eu a de subtração.
12 | 
13 | Quando começamos um projeto, sempre nos encontramos na Master, a branch principal, e quando estamos trabalhando sozinhos ou até mesmo em grupo, é interessante que criemos "cópias" de um momento da nossa master, para podermos trabalhar com as novas features (por exemplo uma nova operação matemática), sem afetar o código que já se encontra funcionando.
14 | Ou seja, quando você fosse desenvolver a funcionalidade de soma da nossa calculadora, você criaria uma branch à parte da master, com tudo que ela possuísse naquele momento para que pudesse criar os códigos sem se preocupar em afetar o código que já possuíamos naquele momento.
15 |
16 | ## 2. Como criar uma branch
17 | Se você deseja criar uma branch via linha de comando, basta ir até o seu terminal (caso você seja usuário de Windows, pode usar o powershell ou, se quiser, baixar o Git Bash [aqui](https://gitforwindows.org/)) e digitar dentro da pasta onde está o seu projeto:
18 |
19 | git branch nome-da-sua-branch
20 | E depois para acessar a branch:
21 |
22 | git checkout nome-da-sua-branch
23 | Caso você queira em qualquer momento saber em qual branch se encontra, basta digitar:
24 |
25 | git branch
26 | E a branch onde você se encontra vai aparecer com um * ao lado e colorida, dependendo do terminal que você esteja usando.
27 | Caso queira ganhar tempo criando a branch e já indo para ela, basta digitar:
28 |
29 | git checkout -b nome-da-sua-branch
30 | E assim que a branch for criada, você já será levado para ela.
31 | Vale ressaltar que é uma boa prática darmos o nome às nossas branches com referência à feature que iremos desenvolver nelas, o que no nosso caso, seria "soma", por exemplo.
32 |
33 | **Caso você esteja usando o github, basta seguir os seguintes passos**
34 | Abra seu repositório depois de realizar o Fork ou criar um repositório novo.
35 | 
36 | Clique onde está escrito master, e digite lá o nome da branch que deseja criar
37 | 
38 | Depois disso basta clicar em *Create branch*, para que a branch seja criada remotamente.
39 |
40 | ## 3. Como alternar entre branches
41 | Conforme explicado acima, podemos usar `git checkout nome-da-branch` para alternar entre as branches, mas existe outra forma também, que é:
42 |
43 | git switch nome-da-branch
44 | Que funciona da mesma forma que a anterior, e pode ser usada para navegar entre as branches.
45 | **Para alterar entre as branches no github basta seguir o seguinte passo**
46 | 
47 | Basta clicar em master, e selecionar entre as branches disponíveis, para qual você deseja ir.
48 | ## 4. Como subir uma branch local para um repositório remoto
49 | Antes de subirmos nossa branch, precisamos verificar se nosso repositório local está com o link do repositório remoto configurado.
50 | Para isso, digite no terminal:
51 |
52 | git remote -v
53 | Caso você já tenha algum repositório no github conectado a ele, a resposta vai ser parecida com isso (um exemplo com um repositório meu):
54 | 
55 | No entanto, caso não retorne nada, você pode criar um repositório no seu github e associar a ele através do comando:
56 |
57 | git remote add origin https://github.com/CarolPinheiro/git-e-github.git
58 | E já vai poder subir suas branches.
59 | Para isso, basta inicialmente digitar o comando:
60 |
61 | git add arquivos-alterados
62 | Adiciona os arquivos selecionados para a área de Stage, onde de uma forma simples, você prepara os arquivos para o commit (ou seja, registrar as atualizações e alterações do projeto). Para commitar basta digitar:
63 |
64 | git commit -m "Mensagem do commit"
65 | O **-m** significa 'message', ou seja ali você digita a mensagem que vai registrar aquela alteração, por exemplo "Função de soma criada".
66 | Assim que o commit tiver sido feito, basta ir no terminal e digitar:
67 |
68 | git push
69 | E sua branch já está disponível remotamente no github.
70 | ## 5. O que é um merge?
71 | Estamos entendendo como trabalhar com branchs, mas se quisermos trazer o trabalho que fizermos em uma branch para outra?
72 |
73 | Possuo duas branchs em um repositório GIT, uma chamada "ciclo-de-vida-basico" e a outra "master", estou trabalhando na primeira e após a finalização quero trazer o meu trabalho para "master", pois ela é a principal branch e onde deve ser depositado todo o código que funciona.
74 |
75 | Como fazer isso? Através do **merge**, que é quando pegamos um código de uma branch e adicionamos à outra branch, unificando assim as alterações. É importante para manter sua branch atualizada ou para levar seu código para a branch principal.
76 |
77 | Para unificar duas branchs, ou seja, fazer com que o conteúdo da primeira seja adicionado à segunda, utilizamos o comando `git merge nome-da-branch-a-ser-mergeada` na branch de destino.
78 |
79 | Abaixo um exemplo de **merge**:
80 |
81 | 1º Fazer checkout na branch de destino. Minha branch de destino é master, então farei: `git checkout master`.
82 |
83 | git checkout nome-da-branch-destino
84 |
85 | 2º Executar o merge para unificar sua branch na de destino. Como o nome da minha branch é ciclo-de-vida-basico, farei: `git merge ciclo-de-vida-basico`.
86 |
87 | git merge nome-da-branch-a-ser-mergeada
88 |
89 | Esse comando fará que o GIT automaticamente crie um commit com o branch atual e todo o conteúdo da branch origem.
90 |
91 | ### Exemplo de um merge local:
92 |
93 | Após fazer commit das alterações na minha branch de trabalho, estou apta para fazer merge:
94 |
95 | 
96 |
97 |
98 |
--------------------------------------------------------------------------------
/dicas-boas-praticas/dicas-de-boas-praticas.md:
--------------------------------------------------------------------------------
1 | # Dicas de boas práticas
2 |
3 | ### Quando devo fazer um commit?
4 |
5 | O ideal é que você faça um commit a cada nova atualização funcional do seu código, para que você possa retornar a uma versão de trabalho, se necessário. Além disso, cada commit deve ter uma tarefa lógica que pode ser resumida em uma frase.
6 |
7 | ### Quando devo fazer um push?
8 |
9 | Sempre, logo depois de fazer um commit.
10 |
11 | ### Eu devo escrever mensagens de commit?
12 |
13 | Você precisa pelo menos de um título descritivo. Esta é uma parte importante da documentação do código \(especialmente em um ambiente de desenvolvimento em time\).
14 |
15 |
--------------------------------------------------------------------------------
/dicas-boas-praticas/explicacao-sobre-cherry-pick.md:
--------------------------------------------------------------------------------
1 | # Explicando o Cherry Pick
2 |
3 | O **Cherry pick** é um comando do git que permite escolher commits específicos de uma branch e anexar a outra branch.
4 |
5 | Este é um recurso interessante quando temos equipes que precisam trabalhar de forma concomitante em um mesmo código. Imagine o cenário em que você está trabalhando em uma **branch A** enquanto uma colega está trabalhando em uma **branch B**.
6 | Em um determinado momento vocês esbarram em um erro que afeta ambas as branchs e é feita a correção na **branch A** mas o trabalho ainda está em andamento e não é possivel realizar o `merge` para propagar as correções. O **cherry pick** será o recurso que permitirá pegar o commit da correção e copia-lo para a **branch B**.
7 |
8 | **Importante!!** O uso do **cherry pick** deve ser moderado para evitar duplicação de commits. Sempre que possível utilize o **rebase** ou o **merge** para manter as branchs atualizadas, analisando as particularidades de cada situação para escolher o comando que melhor se encaixa.
9 |
10 | ### Como realizar um cherry pick em uma branch
11 |
12 | O primeiro passo é descobrir o ID do commit que deseja realizar o **cherry picking**.
13 |
14 | ```bash
15 | $ git checkout branch_feature # indo para branch da feature
16 | $ git log # mostra o log dos commits realizados na branch selecionada
17 |
18 | commit f6b178b6a2105718c4980f8c3e71a9d66462f7c8
19 | Author: Letícia Vargas
20 | Date: Wed Oct 20 20:00:07 2021 -0300
21 | ```
22 |
23 | Depois de copiar o ID do commit, volte para a branch que deseja colar o commit e faça o picking.
24 |
25 | ```bash
26 | $ git checkout outra_branch # volta para a branch destino
27 | $ git cherry-pick f6b178b6a2105718c4980f8c3e71a9d66462f7c8 # cherry picking usando o ID do commit desejado
28 | ```
29 |
30 | ### Copiando um intervalo de commits
31 |
32 | Caso você precise copiar uma série de commits, o git **cherry pick** permite informar um intervalo de IDs para copiar o grupo de uma vez só. Para isso você deve informar o ID do commit inicial e o ID do commit final.
33 |
34 | Se desejar copiar todos os commits incluindo o primeiro:
35 |
36 | ```bash
37 | $ git cherry-pick id_inicial^..id_final # você deve adicionar o acento circunflexo para incluir o commit inicial
38 | ```
39 |
40 | Mas se o primeiro commit deve ser igorado:
41 |
42 | ```bash
43 | $ git cherry-pick id_inicial..id_final # você não precisa adicionar o acento
44 | ```
45 |
46 | ### Principais parâmetros do cherry pick
47 | - `-e` : Permite editar a mensagem do commit.
48 | - `-x` : Adiciona uma mensagem ao commit indicando que é um cherry pick `cherry picked from commit`
49 | - `-allow-empty` : Permite commits em branco (por padrão o cherry pick não permite commits em branco).
50 | - `-allow-empty-message` : Permite commit sem título (por padrão commits sem títulos são barrados).
51 |
52 |
53 | ### E pode ter conflitos?
54 |
55 | Sim, podemos esbarrar em conflitos ao realizar o **cheryy picking**. Temos dois caminhos possíveis:
56 |
57 | - **Desfaser o cherry pick**: Neste caso você utiliza o comando `$git cherry-pick --abort` para desfazer o cherry pick e voltar a brach ao estado inicial.
58 | - **Resolver os conflitos**: Após a analise e resolução dos conflitos você deve usar o comando `$git cherry-pick --continue` para o git continuar o processo de **cherry picking**
59 |
60 |
--------------------------------------------------------------------------------
/dicas-boas-praticas/explicacao-sobre-rebase.md:
--------------------------------------------------------------------------------
1 | # Explicando o Rebase
2 |
3 | O **Rebase** é um comando do git que permite reorganizar, mover ou combinar uma sequência de commits realizados em um repositório.
4 |
5 | Uma boa prática durante o desenvolvimento é a realização de commits a cada atualização funcional, contudo, em alguns casos, ao finalizar uma feature podemos ter um histórico com muitas informações repetidas e até confusas.
6 |
7 | Assim, ao utilizar o **rebase** podemos modificar o histórico do repositório, editando as mensagens, combinando vários commits e até excluindo commits que não são mais necessários no repositório.
8 |
9 | O principal motivo para a utilização do **rebase** está relacionado à manutenção de um histórico linear do projeto, com commits significativos que fornecem informações relevantes sobre as features implementadas.
10 |
11 | **Importante!!** O **rebase** mexe com toda a estrutura das branchs envolvidas, reescrevendo histórico de commits e unificando informações. Assim, todo processo de rebasing deve ser feito com muito cuidado para evitar perdas ao longo do processo, principalmente se o repositório estiver sendo utilizado por várias pessoas de forma concomitante.
12 |
13 | ### Como realizar um rebase em uma branch
14 |
15 | ```bash
16 | $ git checkout branch_feature # indo para a branch da feature
17 | $ git rebase outra_branch # fazendo o rebase entre a branch_feature e a outra_branch
18 | ```
19 |
20 | Com este comando você irá realizar um **rebase** de todos os commits da `outra_branch` em sua branch atual `branch_feature`.
21 |
22 | ### Principais comandos do Rebase
23 |
24 | - `pick` : Mantem o commit como está, não será alterada a mensagem ou o conteúdo do commit.
25 | - `reword` : Semelhante ao `pick`, mas permite alterar a mensagem do commit.
26 | - `edit` : Permite editar um commit, sendo possível adicionar, alterar e dividir commits.
27 | - `squash` : Permite combinar commits em um único commit. O squash realiza a combinação sempre com o commit que está acima dele, sendo possível editar a mensagem de descrição.
28 | - `fixup` : Realiza a combinação de commits de forma semelhante ao `squash`, contudo descarta a mensagem do commit que sofre o merge. A mensagem do commit anterior passa a ser utilizada para descrever ambos commits.
29 | - `exec` : Permite executar comandos shell a cada commit marcado (por exemplo, uma suíte de testes)
30 |
31 | ### E se surgirem conflitos?
32 |
33 | Ao realizar um **rebase** estamos modificando o histórico de commits da branch, logo podemos esbarrar em commits que modificaram um mesmo arquivo. Quando essa situação acontece temos um conflito que o Git precisará de auxílio para resolver.
34 |
35 | Caso existam conflitos o Git irá mostrar qual o commit que precisa de atenção. Você terá as seguintes opções:
36 |
37 | - **Desfazer o rebase** : Neste caso você deve utilizar o comando `$git rebase --abort` para desfazer completamente o rebase, retornando a branch para o estado anterior ao comando `$git rebase`;
38 | - **Ignorar o commit conflituoso** : Você deve utilizar o comando `$git rebase --skip` para ignorar todas as modificações que estão no commit, ou seja, tudo o que foi realizado neste commit será descartado.
39 | - **Corrigir o conflito** : Neste caso você deve analisar os conflitos, realizar as correções necessárias e ao final usar o comando `$git rebase --continue` para o git continuar o processo de rebase.
40 |
--------------------------------------------------------------------------------
/dicas-boas-praticas/explicacao-sobre-squash.md:
--------------------------------------------------------------------------------
1 | # Explicando o Squash Commit
2 |
3 | O **squash** é um recurso utilizado para combinar commits. É um comando que tem por objetivo organizar o histórico de commits que pode estar poluído com uma série de pequenos commits realizados ao longo do desenvolvimento.
4 |
5 | Com o **squash** mudamos o histórico dos commits agrupando, de uma forma mais significativa, as modificações realizadas.
6 |
7 | ### Como realizar um squash commit
8 |
9 | O **squash** geralmente é realizado em conjunto com o **rebase** (leia mais sobre o rebase [aqui](dicas-boas-praticas/explicação-sobre-rebase.md)).
10 |
11 | ```bash
12 | $ git log # listar os commits da branch atual
13 | $ git rebase -interactive HEAD~2 # iniciar o rebase com a opção de interatividade
14 | ```
15 |
16 | O argumento `HEAD` referencia o commit mais atual e o `~2` informa ao git que queremos interagir com o segundo commit a partir do mais atual.
17 |
18 | Ao executar este comando temos acesso a um aquivo temporário para realização das alterações desejadas. Teremos um arquivo semelhante a este:
19 |
20 | ```bash
21 | pick 3c71782 Update de contagem
22 | pick 868bdc9 Adicionado novo parametro
23 | pick e23462b Opção de excluir parametro
24 | pick 5c07067 Adicionado modal de erro
25 |
26 | # Rebase 6eaddcd..5c07067 onto 6eaddcd
27 | #
28 | # Commands:
29 | # p, pick = use commit
30 | # r, reword = use commit, but edit the commit message
31 | # e, edit = use commit, but stop for amending
32 | # s, squash = use commit, but meld into previous commit
33 | # f, fixup = like "squash", but discard this commit's log message
34 | # x, exec = run command (the rest of the line) using shell
35 | #
36 | # These lines can be re-ordered; they are executed from top to bottom.
37 | #
38 | # If you remove a line here THAT COMMIT WILL BE LOST.
39 | #
40 | # However, if you remove everything, the rebase will be aborted.
41 | #
42 | # Note that empty commits are commented out
43 | ```
44 |
45 | Será apresentada a lista de opções do **rebase** e para o **squash** temos duas opções:
46 |
47 | - `squash` : Adiciona no histórico a informação de que foi realizado um squash
48 | - `fixup` : Não adiciona a informação do squash no histórico
49 |
50 | O arquivo é aberto no terminal utilizando o `vim`, para interagir com o terminal, digite `i`.
51 |
52 | Para realizar o squash basta editar o arquivo adicionando a opção desejada nos commits:
53 |
54 |
55 | ```bash
56 | pick 3c71782 Update de contagem
57 | squash pick 868bdc9 Adicionado novo parametro
58 | squash pick e23462b Opção de excluir parametro
59 | pick 5c07067 Adicionado modal de erro
60 |
61 | ```
62 |
63 | No exemplo, as linhas dos commits `868bdc9` e `e23462b` foram marcadas como `squash` e serão combinadas ao commit que está logo acima `3c71782`.
64 |
65 | Esse é um ponto importante, o squash sempre irá agrupar os commits com aquele logo acima, ou seja, você sempre irá fazer o **squash** de um commit mais antigo para um mais novo.
66 |
67 | Feitas as alterações, basta salvar o arquivo. No terminal você terá a opção de mudar as mensagens dos commits e assim que você salvar o squash estará pronto.
68 |
69 | ### Squash + merge
70 |
71 | Outra opção é utilizar o **squash** no momento que for realizado o `merge` de uma branch.
72 |
73 | ```bash
74 | $ git merge --squash branch_origem # indicar a branch da qual queremos buscar os commits
75 | ```
76 |
77 | Com este comando o git irá pegar todos os commits da branch informada, realizar um `squash` agrupando tudo em um commit único e então realizar o `merge` da branch.
78 |
--------------------------------------------------------------------------------
/git-e-github/conceitos-e-vocabulario-do-git.md:
--------------------------------------------------------------------------------
1 | ---
2 | description: >-
3 | Neste vocabulário reunimos as expressões mais comuns, utilizadas para
4 | referenciar comandos de versionamento de projetos com Git (que valem para
5 | GitHub também!)
6 | ---
7 |
8 | # Vocabulário do Git
9 |
10 | ## Versionamento
11 |
12 | O versionamento de software é um processo de controle de versões, estabelecido por meio de "numerações" de históricos diferentes. Isso permite que os programadores e programadoras saibam quando e quais alterações foram realizadas, acompanhando as mudanças aplicadas no software.
13 |
14 | ## Repositório
15 |
16 | O repositório é a pasta do projeto. Todo repositório tem uma pasta oculta .git. Isso é o que mostra para o git e para você que existe um repositório naquela pasta.
17 |
18 | ## Change \(ou Diff\)
19 |
20 | O Git mantém o controle de versão rastreando as mudanças ou diferenças entre as versões dos arquivos. Você pode alterar um arquivo fazendo uma das duas coisas:
21 |
22 | 1. Criação, renomeação ou exclusão de arquivos.
23 | 2. Inserção ou exclusão de uma linha em um arquivo \(uma linha modificada é uma inserção e uma exclusão\)
24 |
25 | O Git representa inserções ou alterações adicionadas com um `+` e exclusões ou alterações removidas com um `-`
26 |
27 | ## Commit
28 |
29 | Um commit é um grupo de alterações no código. Toda vez que você quiser "salvar" as alterações feitas por você no repositório, você commita essas mudanças. Um commit contém as alterações que foram feitas nele e uma mensagem descritiva, além de informações meta \(data, autor, etc\).
30 |
31 | ## Branch
32 |
33 | Branches são separações de código. O branch padrão do projeto é o master. Branches normalmente são utilizados para separar alterações grandes ou novas funcionalidades do projeto.
34 |
35 | ## Merge
36 |
37 | Um merge é a união de duas branches, normalmente, merges são feitos na branch master. No exemplo do blog, quando a alteração do blog for terminada, alguém vai unir essas alterações na branch master para que elas possam finalmente fazer parte do projeto de fato.
38 |
39 | ## Clone
40 |
41 | Um clone de um repositório funciona como uma branch de um repositório online em um repositório local. Ou seja, quando se deseja trabalhar em um repositório hospedado no github, clona-se esse repositório para o seu computador, trabalha-se nele, e então é pedida a permissão para atualizar as alterações online.
42 |
43 | ## Pull
44 |
45 | É uma atualização do repositório local. É feito um merge do repositório online com o local para que os conflitos sejam resolvidos e seja possível enviar o código \(sem conflitos\) para o repositório online por meio de um push.
46 |
47 | ## Push
48 |
49 | Envia o código para o repositório online.
50 |
51 | ## Fork
52 |
53 | O fork é como um clone, porém dentro do github. Isso quer dizer que o repositório não vai ser baixado para seu computador, mas será criado um igual na sua conta.
54 |
55 | ## Pull Request
56 |
57 | Um pull request é um pedido que se faz ao dono do repositório para que este atualize o código dele com o seu código. Ou seja, você pede para que o dono do projeto ao qual você quer contribuir adicione suas modificações ao projeto oficial.
58 |
--------------------------------------------------------------------------------
/git-e-github/setup-de-instalacao.md:
--------------------------------------------------------------------------------
1 | # Setup de Instalação
2 |
3 | ## Instalando o Git
4 |
5 | Instale o Git, no seu computador, através do Terminal para Mac ou Ubuntu e instalador para Windows.
6 |
7 | ### Mac
8 |
9 | Para instalar no Mac, você precisará ter o [Homebrew](https://brew.sh/index_pt-br) instalado, abrir o Terminal e digitar o comando:
10 |
11 | ```css
12 | $ brew install git
13 | ```
14 |
15 | Após digitar este comando, aperte enter e aguarde a execução da instalação.
16 |
17 | ### Ubuntu / Linux
18 |
19 | Abra o seu terminal e digite o seguinte comando
20 |
21 | ```css
22 | $ apt install git
23 | ```
24 |
25 | Dica: se você estiver com algum problema, tente seguir nosso [passo a passo detalhado](setup-instalacao-linux.md).
26 |
27 | ### Windows
28 |
29 | Para instalar no Windows, faça download do instalador em: [http://git-scm.com/downloads](http://git-scm.com/downloads)
30 |
31 | Dica: se você estiver com algum problema, tente seguir nosso [passo a passo detalhado](setup-instalacao-windows.md).
32 |
33 | Dica: Para verificar se o git já está instalado, abra o Terminal e digite `$ git`
34 |
35 | ## Configurando sua conta em seu computador
36 |
37 | Configure suas informações de usuário, para que todos os repositórios em que você irá trabalhar localmente estejam atrelados à sua conta. Para isso, abra o Terminal e digite os seguintes comandos:
38 |
39 | * Nome de usuário:
40 |
41 | ```css
42 | $ git config --global user.name "[nome]"
43 | ```
44 |
45 | * E-mail da sua conta:
46 |
47 | ```css
48 | $ git config --global user.email "[endereco-de-email]"
49 | ```
50 |
51 | *Lembre-se de substituir a informação entre `[colchetes]`pelos seus dados.*
52 |
--------------------------------------------------------------------------------
/git-e-github/setup-instalacao-linux.md:
--------------------------------------------------------------------------------
1 | # Instalando, configurando e inicializando o Git no Linux
2 |
3 |
4 | Para instalar o Git no Linux, digite no terminal:
5 |
6 | ```
7 | $ sudo apt install git
8 | ```
9 |
10 | - **$** indica que você deve usar o **usuário comum** para fazer essa operação.
11 |
12 | - **sudo** é o comando que dá permissões de super usuário temporariamente; assim é possível fazer a instalação de programas.
13 |
14 | - **apt** do inglês, *Advanced Package Tool*, em português, Ferramenta de Empacotamento Avançada; é a ferramenta que nos ajuda na instalação, atualização e desinstalação de programas, entre outras funções.
15 |
16 | - **install** é o comando de instalar, indicando ao apt o que fazer.
17 |
18 | Verifique se a instalação foi feita corretamente digitando:
19 |
20 | ```
21 | $ git --version
22 | ```
23 |
24 | Você receberá o retorno da versão instalada.
25 |
26 | Antes de começar a usá-lo é preciso fazer as configurações iniciais. Assim,
27 |
28 | ```
29 | $ git config --global user.name
30 | ```
31 |
32 | - Digite seu nome sem os sinais de < e >.
33 |
34 | Em seguida:
35 |
36 | ```
37 | $ git config --global user.email
38 | ```
39 |
40 | - Digite seu email sem os sinais de < e >.
41 |
42 | Configurando o editor padrão:
43 |
44 | ```
45 | $ git config --global core.editor nano
46 | ```
47 |
48 | No meu caso, estou usando o **nano**, mas você pode utilizar outro de sua preferência.
49 |
50 | Para verificar as suas configurações:
51 |
52 | ```
53 | $ git config --list
54 | ```
55 |
56 | Caso queira que as configurações sejam feitas apenas no diretório (não global) indicado, basta retirar dos comandos a flag **--global**. Assim:
57 |
58 | ```
59 | $ git config user.name
60 | $ git config user.email
61 | $ git config core.editor nano
62 | ```
63 |
64 | Para inicializar o git no diretório desejado (caso ainda não o tenha feito), vá até o local onde você deseja fazer o controle de versionamento.
65 |
66 | ```
67 | $ cd /home/seu_usuário/seu_repositório
68 | ```
69 |
70 | - **cd** do inglês, change directory; serve para mudar de diretório/pasta.
71 |
72 | e digite
73 |
74 | ```
75 | $ git init
76 | ```
77 |
78 | A partir de agora, os arquivos serão rastreados pelo **Git**.
79 |
--------------------------------------------------------------------------------
/git-e-github/setup-instalacao-windows.md:
--------------------------------------------------------------------------------
1 | # Instalando, configurando e inicializando o Git no Windows
2 |
3 |
4 | Para instalar o **Git** no Windows, [acesse o site oficial](https://git-scm.com/download/win).
5 |
6 | Após baixar o **instalador** execute-o para **começar a instalação**.
7 |
8 | 
9 |
10 | Na primeira tela nos são apresentados os **termos da licença de utilização** do **Git**.
11 |
12 | Basta clicar em **Next**.
13 |
14 | 
15 |
16 | A tela seguinte é sobre o **local de instalação**. Você pode alterá-la, caso queira. Após definir o local da instalação, clique em **Next**.
17 |
18 | 
19 |
20 | Na próxima tela, o instalador oferece a possibilidade de selecionar os **componentes** que queremos que sejam instalados. Escolha os **componentes** de sua preferência e clique em **Next**.
21 |
22 | Abaixo um exemplo de como prefiro os meus:
23 |
24 | 
25 |
26 | Em seguida o instalador nos indica que criará uma pasta com **atalhos** no **menu iniciar**. Aqui você pode fazer de acordo com a sua preferência. No meu caso eu deixei o instalador criar os atalhos.
27 |
28 | Clique em **Next** para continuar a instalação.
29 |
30 | 
31 |
32 | Na sequência, é pedido para selecionarmos o **editor de texto** que deve ser utilizado para editar os conflitos que ocorrerão. Aqui, eu aconselho a instalar seu editor preferido, antes da instalação do **Git** para que o instalador possa encontrá-lo. De todo modo, também é possível fazer a troca posteriormente.
33 |
34 | Após a escolha, clique em **Next** para continuar.
35 |
36 | 
37 |
38 | Em seguida, o instalador nos pergunta se queremos usar os comandos do **Git**:
39 |
40 | - somente no prompt de comandos do próprio git (chamado de Git Bash), neste caso ele não vai alterar a variável de ambiente PATH.
41 |
42 | - no **prompt do Windows** neste caso a variável de ambiente PATH será alterada para incluir o caminho onde está o executável do **Git**.
43 |
44 | - no prompt do Windows e com os comandos utilitários do Linux. Aqui a variável de ambiente PATH será alterada para incluir o caminho do executável do **Git** e dos executáveis de cada comando utilitário do **Linux**.
45 |
46 | Particularmente, prefiro essa última opção, porque o instalador traz para o **Windows** comandos que eu uso muito no terminal do **Linux**, como touch, cat, ls, etc.
47 |
48 | Escolha a opção que acha mais adequada para você e clique em **Next**.
49 |
50 | 
51 |
52 | Na sequência, devemos escolher a biblioteca de **validação de chaves de segurança SSL**. Eu costumo utilizar a **OpenSSL**, que é compatível com outras plataformas.
53 |
54 | Em seguida, clique em **Next**.
55 |
56 | 
57 |
58 | Aqui, o instalador nos pergunta como o **Git** deve tratar o final dos arquivos de texto. **Linux** e **Windows** tratam disso de formas diferentes. De maneira resumida, o **Linux** usa um caractere ASCII para a quebra de linha, enquanto o **Windows** usa dois.
59 |
60 | Eu prefiro a primeira opção, para evitar problemas de compatibilidade.
61 |
62 | 
63 |
64 | Na próxima tela, o instalador oferece a opção de escolher o emulador de terminal que queremos usar para o **Git**. Particularmente, acho melhor escolher o **MinTTY**, porque ele oferece alguns recursos melhores para terminal.
65 |
66 | **Atenção aqui**: se seu **Windows** for **32 bits** é melhor escolher o **cmd**.
67 |
68 | 
69 |
70 | Na sequência devemos escolher o comportamento padrão de comando **git pull**. Eu preferi deixar marcada a primeira opção.
71 |
72 | Em seguida, clique em **Next**.
73 |
74 | 
75 |
76 | Estamos quase finalizando. Nessa tela temos algumas opções de:
77 |
78 | - habilitar **cache de arquivos na memória**. Isso melhora o desempenho do **Git** em alguns casos.
79 |
80 | - habilitar o gerenciador de credenciais do **Git**. Isso permite autenticação em duas etapas no **Github**.
81 |
82 | - habilitar links simbólicos.
83 |
84 | 
85 |
86 | Por último, o instalador nos oferece alguns componentes que estão em fase de experimentação. Aqui fica totalmente a seu critério. Eu prefiro não instalá-los.
87 |
88 | 
89 |
90 | Então, clique em **Install** para começar a instalação.
91 |
92 | 
93 |
94 | Depois da instalação, já podemos rodar o **Git Bash** e ver o arquivo de texto com as notas da versão lançada.
95 |
96 | Para finalizar clique em **Finish**.
97 |
98 | 
99 |
100 | Agora você já pode versionar seus códigos no Windows! =D
101 |
--------------------------------------------------------------------------------
/git-e-github/setup.md:
--------------------------------------------------------------------------------
1 | ---
2 | description: >-
3 | Faremos nosso treinamento focado em trabalhar com o GitHub, como plataforma de
4 | versionamento. Para isso, siga os passos a seguir e crie sua conta gratuita.
5 | ---
6 |
7 | # Criando uma conta e seu primeiro repositório no GitHub
8 |
9 | ## Criando uma conta no GitHub
10 |
11 | O GitHub permite você criar uma conta gratuita, para isso, basta acessar [https://github.com/](https://github.com/) e seguir as instruções na tela para criar uma conta de usuário.
12 |
13 | 
14 |
15 | Dica: escolha um nome de usuário sem caracteres especiais como ç e acentos.
16 |
17 | ## Criando um repositório no GitHub
18 |
19 | Repositório é um diretório onde os arquivos do seu projeto ficam armazenados. Ele pode ficar em um depósito do GitHub ou em seu computador. Você pode armazenar códigos, imagens, áudios, ou qualquer outra coisa relacionada ao projeto no diretório.
20 |
21 | ### Iniciando
22 |
23 | 1. No canto superior direito da página, clique no menu + e selecione a opção "New repository" (Novo repositório)
24 |
25 | 
26 |
27 | 2. Informe um nome sem espaços e caracteres especiais, de preferência um nome curto e fácil de memorizar. Por exemplo: "hello-world" (ola-mundo).
28 |
29 | 
30 |
31 | 3. Se desejar, adicione uma descrição do repositório. Por exemplo, "My first repository on GitHub" (Meu primeiro repositório no GitHub).
32 |
33 | 
34 |
35 | 4. Informe a visibilidade do seu repositório:
36 | - Public: Qualquer pessoa na internet pode ver este repositório.
37 | - Internal: Repositório da organização e que será visivel somente a seus colaboradores. Obs: Essa opção só vai aparecer para você, se sua conta do GitHub for empresarial.
38 | - Private: Você decide quem pode visualizar e contribuir com este repositório.
39 |
40 | 
41 |
42 | 5. Inicie o seu repositório com um README (LEIAME), este arquivo irá servir para descrever melhor o seu projeto e fornecer instruções de como utilizar.
43 |
44 | 
45 |
46 | 6. Conclua a criação do repositório, clicando no botão "Create repository" (Criar repositório).
47 |
48 | 
49 |
50 | ###
51 |
52 |
--------------------------------------------------------------------------------
/hands-on/exercicio-1.md:
--------------------------------------------------------------------------------
1 | ---
2 | description: 'Exercício para você praticar :)'
3 | ---
4 |
5 | # Exercício 1
6 |
7 | ## Proposta
8 |
9 | Praticar a adição, commit e push para o GitHub.
10 |
11 | ## Passos para realização:
12 |
13 | ### 1. Conteúdo do projeto
14 |
15 | 1. Crie uma pasta com o nome do projeto \(a sua escolha\) e um arquivo chamado `index.html`
16 | 2. Adicione o seguinte conteúdo ao arquivo:
17 |
18 | ```markup
19 |
20 |
21 |
22 | Título da página
23 |
24 |
25 |
26 | Aqui vai um título
27 |
28 |
29 | ```
30 |
31 | ### 2. Subindo seu projeto para o GitHub
32 |
33 | 1. [Crie um repositório](../git-e-github/setup.md) em seu GitHub
34 | 2. Abra o seu terminal de comando e adicione a [origem remota](../ciclo-de-vida-basico/criando-um-repositorio.md) e conecte seu projeto local com o GitHub
35 | 3. Verifique as [alterações do seu projeto](../ciclo-de-vida-basico/comandos-mais-utilizados.md#git-status) e [adicione](../ciclo-de-vida-basico/comandos-mais-utilizados.md#git-add) ao fluxo de versionamento
36 | 4. Faça um [commit](../ciclo-de-vida-basico/comandos-mais-utilizados.md#git-commit) com uma mensagem útil e na sequência, um [push](../ciclo-de-vida-basico/comandos-mais-utilizados.md#git-push) para o repositório remoto \(GitHub\)
37 |
38 | ### 3. Lidando com alterações
39 |
40 | Abra a pasta do seu projeto, crie uma pasta chamada `imagens`, procure no Google por uma imagem de gato e salve dentro dessa nova pasta. Feito isso, abra seu arquivo `index.html` e adicione as seguintes modificações e salve o arquivo:
41 |
42 | ```markup
43 |
44 |
45 |
46 | Fanpage de Gatinhos
47 |
48 |
49 |
50 | Perfil #catsoninstagram
51 | 
52 |
53 |
54 | ```
55 |
56 | Agora, repita os passos 2 e 3 do [item 2](exercicio-1.md#2-subindo-seu-projeto-para-o-github).
57 |
--------------------------------------------------------------------------------
/hands-on/exercicio-2.md:
--------------------------------------------------------------------------------
1 | # Exercício 2
2 |
3 | ## Proposta
4 |
5 | Em vários casos, você encontrará arquivos que não pertencem \(ou não deveriam\) ao repositório. Exemplos típicos incluem:
6 |
7 | * Credenciais \(exemplo: senhas, usuários, keys\)
8 | * Cache de arquivos \(exemplo: .pyc\)
9 | * Ferramentas e bibliotecas complementares para execução do projeto \(exemplo: node\_modules\)
10 |
11 | O Git permite que os usuários adicionem um arquivo [`.gitignore`](../ciclo-de-vida-basico/o-que-e-o-.gitignore.md) ao seu projeto, na raiz da pasta, para ignorar esses arquivos específicos.
12 |
13 | ## Passos para realização:
14 |
15 | ### Criando um arquivo não rastreável
16 |
17 | 1. Acesse a pasta do projeto que você criou no exercício 1 e crie um arquivo chamado `minhas_senhas_secretas.txt`
18 | 2. Abra o terminal e veja se o arquivo está aparecendo como não rastreado e que pode ser adicionado \([dica](../ciclo-de-vida-basico/comandos-mais-utilizados.md#git-status)\)
19 |
20 | ### Gerando o .gitignore
21 |
22 | 1. Crie o arquivo `.gitignore` e salve-o na raiz do projeto \(ele deverá aparecer no mesmo nível dos arquivos `index.html` e da pasta `imagens`\)
23 | 2. Abra o arquivo `.gitignore`, digite `minhas_senhas_secretas.txt` e salve-o
24 | 3. No terminal, digite novamente o comando para verificar o status dos arquivos e veja que o `minhas_senhas_secretas.txt` não aparece mais!
25 |
26 | ### Publicando seu .gitignore
27 |
28 | No seu terminal, rode os comandos:
29 |
30 | 1. `git add` para adicionar o arquivo
31 | 2. `git commit` para commitar o novo arquivo, sem esquecer de adicionar uma mensagem útil e informativa sobre o que será publicado
32 | 3. `git push` para enviar para o repositório no GitHub
33 |
--------------------------------------------------------------------------------
/hands-on/exercicio-3.md:
--------------------------------------------------------------------------------
1 | # Exercício 3
2 |
3 | ## Proposta
4 |
5 | Praticar alguns comandos básicos no que diz respeito ao manejo do seu repositório.
6 |
7 | ## Passos para realização
8 |
9 | ### 1. Clonando seu repositório
10 |
11 | 1. No seu perfil do GitHub na aba `Repositories`, crie um novo repositório clicando no botão `New`
12 | 2. Se desejar selecione a opção `Add a README file` para criar um arquivo de apresentação
13 | 3. Na página do seu repositório copie o link HTTPS ou SSH (se já houver configurado) utilizando o botão code
14 | 4. Abra o seu terminal na pasta em que deseja clonar o repositório ou utilize o comando `cd` no terminal pra chegar até lá
15 | 5. Utilize o comando `git clone link-HTTPS/SSH` para clonar o seu repositório
16 |
17 | ### 2. Criando sua nova branch & commit de mudanças
18 |
19 | 1. No terminal escreva o comando `git checkout -b nome-da-sua-branch` para criar a branch e mudar para ela diretamente
20 | 2. Abra o seu editor favorito e faça suas modificações, não se esqueça de salvar! :blue_heart:
21 | 3. Voltando para o terminal e dentro da pasta do projeto, use o comando `git add .` para preparar todos os arquivos modificados para o commit
22 | 4. Agora use o comando `git commit -m "aqui sua mensagem de commit"` para fazer o commit das suas mudanças na branch
23 | 5. Para enviar seu commit para seu repositório remoto utilize o comando `git push origin nome-da-sua-branch`
24 |
25 | ### 3. Fazendo Pull Request (PR) & dando merge
26 |
27 | 1. No site do GitHub e na sua página do repositório na aba `Pull requests` clique no botão `New pull request`
28 | 2. Agora ajuste nas opções para qual branch você quer enviar as suas modificações (lado esquerdo) e a sua branch que estará enviando essas modificações (lado direito)
29 | 3. Observe se não há qualquer conflito, caso não haja confirme a PR!
30 | 4. Agora você só precisa fazer o merge, para isso na mesma aba do passo 1, clique na PR que deseja dar merge
31 | 5. Como não há nenhum conflito entre as branches (passo 3) é só clicar no botão `Merge pull request`
32 | 6. Parabéns, você conseguiu! :tada:
33 |
--------------------------------------------------------------------------------
/hands-on/exercicio-4.md:
--------------------------------------------------------------------------------
1 | # Exercício 4
2 |
3 | ## Proposta
4 |
5 | Adicionar um repositório remoto ao seu projeto local.
6 |
7 | ## Passos para realização:
8 |
9 | ### Adicionando um repositório remoto ao seu projeto local.
10 |
11 | 1. [Crie um repositório](https://github.com/WoMakersCode/git-e-github/blob/master/git-e-github/setup.md) no seu GitHub.
12 | 2. Acesse o diretório do seu projeto.
13 | ```
14 | $ cd /Users/WoMakersCode/projeto
15 | ```
16 | 3. Inicie o Git dentro dessa pasta
17 | ```
18 | $ git init
19 | ```
20 | 4. Víncule o repositório local com o repositório o remoto.
21 | ```
22 | $ git remote add origin https://github.com/WoMakersCode/git-e-github.git
23 | ```
24 |
25 | Pronto! Está vinculado.
26 | Ops, sua conta não esta configurada? Lembre-se de autenticar o seu usuário.
27 |
28 | 5. Autentique o seu usuário.
29 | ```javascript
30 | // Seu nome e sobrenome
31 | $ git config user.name "Nome Sobrenome"
32 |
33 | // Email cadastrado no github
34 | $ git config user.email "nome.sobrenome@email.com.br"
35 | ```
36 |
37 | ### Criando uma nova branch
38 |
39 | 1. Acesse o diretório do seu projeto.
40 | ```
41 | $ cd /Users/WoMakersCode/projeto
42 | ```
43 | 2. Crie sua nova branch.
44 | ```
45 | $ git checkout -b nome-da-sua-branch
46 | ```
47 | 2. Acesse o seu editor no diretório do projeto.
48 | - Caso seja o VS Code, utilize o comando `code .`
49 |
50 |
51 | Você também pode verificar em qual branch está no momento ou alterar entre as branchs já criadas.
52 | 3. Verificando sua branch e alterações.
53 | ```
54 | $ git status
55 | ```
56 | 4. Alterar a branch atual para uma já existente.
57 | ```
58 | $ git checkout branch-existente
59 | ```
60 |
61 | ### Adicionando arquivos, comitando e enviando para o seu repositório remoto
62 |
63 | 1. Adicione as alterações feitas.
64 | ```javascript
65 | // Adicionar todas as alterações
66 | $ git add .
67 |
68 | // Adicionar ou alterar arquivo especifico, utilize a pasta e a extensão dele.
69 | $ git add hands-on/exercicio-4.md
70 | ```
71 | 2. Commite as alterações adicionadas.
72 | ```
73 | $ git commit -m "Adicionando o exercicio 4"
74 | ```
75 | 3. Envie para o repositório remoto
76 | ```javascript
77 | // Caso esteja confiante do seu código, pode subir direto na branch principal.
78 | $ git push origin master
79 |
80 | // Caso esteja fazendo alterações com outras pessoas, é preferivel utilizar apenas na sua branch.
81 | $ git push origin minha-branch
82 | ```
83 |
84 | ### Fazendo uma pull request
85 |
86 | Acesse o seu repositório no GitHub
87 | 
88 | 1. Peça um pull request para suas alterações.
89 |
90 | Pedindo um pull request.
91 | 
92 | 1. Certifique-se do direcionamento do seu pull request, para onde vai e de onde vem o código.
93 | 2. Verifique as mudanças que estão vínculadas.
94 | 3. Crie o pull request.
95 |
96 | Criando o pull request.
97 | 
98 | 1. Coloque um título simples mas objetivo
99 | 2. Crie uma descrição explicita do que foi alterado ou criado.
100 | 3. Vefique as mudanças novamente.
101 | 4. CRIE O PULL REQUEST.
102 |
103 | Parabéns, o seu código já está na lista para ser mergeado com o repositório principal! :heart:
104 |
--------------------------------------------------------------------------------
/images/alternate-between-branches.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/alternate-between-branches.png
--------------------------------------------------------------------------------
/images/create-branches-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/create-branches-1.png
--------------------------------------------------------------------------------
/images/create-branches-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/create-branches-2.png
--------------------------------------------------------------------------------
/images/git-remote-v.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/git-remote-v.png
--------------------------------------------------------------------------------
/images/hands-on-fork-1.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/hands-on-fork-1.PNG
--------------------------------------------------------------------------------
/images/hands-on-fork-2.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/hands-on-fork-2.PNG
--------------------------------------------------------------------------------
/images/hands-on-fork-3.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/hands-on-fork-3.PNG
--------------------------------------------------------------------------------
/images/hands-on-fork.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/hands-on-fork.PNG
--------------------------------------------------------------------------------
/images/hands-on-merge.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/hands-on-merge.png
--------------------------------------------------------------------------------
/images/p0001-0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-0.png
--------------------------------------------------------------------------------
/images/p0001-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-1.png
--------------------------------------------------------------------------------
/images/p0001-10.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-10.png
--------------------------------------------------------------------------------
/images/p0001-11.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-11.png
--------------------------------------------------------------------------------
/images/p0001-12.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-12.png
--------------------------------------------------------------------------------
/images/p0001-13.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-13.png
--------------------------------------------------------------------------------
/images/p0001-14.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-14.png
--------------------------------------------------------------------------------
/images/p0001-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-2.png
--------------------------------------------------------------------------------
/images/p0001-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-3.png
--------------------------------------------------------------------------------
/images/p0001-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-4.png
--------------------------------------------------------------------------------
/images/p0001-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-5.png
--------------------------------------------------------------------------------
/images/p0001-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-6.png
--------------------------------------------------------------------------------
/images/p0001-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-7.png
--------------------------------------------------------------------------------
/images/p0001-8.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-8.png
--------------------------------------------------------------------------------
/images/p0001-9.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WoMakersCode/git-e-github/86d36cd381c9cf57b59cfdd94fe3c0040b7e8859/images/p0001-9.png
--------------------------------------------------------------------------------
/o-que-onde-e-por-que.md:
--------------------------------------------------------------------------------
1 | ---
2 | description: O que são as ferramentas de versionamento e por que utilizar em seus projetos.
3 | ---
4 |
5 | # O que é, o que é?
6 |
7 | ## Git
8 |
9 | O Git é um sistema de controle de versão distribuído, gratuito e de código aberto, projetado para lidar com tudo, desde projetos pequenos a muito grandes, com velocidade e eficiência.
10 |
11 | ## GitHub
12 |
13 |
14 | **GitHub** é uma plataforma de hospedagem de código-fonte com controle de versão usando o Git. Ele permite que programadoras e programadores, utilitários ou qualquer usuário cadastrado na plataforma contribuam em projetos privados e/ou Open Source de qualquer lugar do mundo.
15 |
16 |
17 | ## Por que utilizar em seus projetos?
18 |
19 | * Manter um histórico completo de alterações
20 | * Permite que vários programadores trabalhem na mesma base de código
21 | * É eficiente e leve \(altera o arquivo de registros, não o conteúdo do arquivo\)
22 | * Repositórios públicos no GitHub podem servir como um currículo de codificação.
23 |
24 |
--------------------------------------------------------------------------------