-
Notifications
You must be signed in to change notification settings - Fork 4
/
cap02.Rmd
393 lines (306 loc) · 12.6 KB
/
cap02.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
---
title: "Instalação e Configuração"
author: "PET Estatística UFPR"
date: "29/10/2015"
graphics: yes
output:
pdf_document:
template:
highlight: default
toc: true
toc_depth: 2
keep_tex: true
number_sections: true
---
```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```
Agora, devidamente apresentados ao sistema de versionamento Git vamos
utilizá-lo. Porém, antes de começarmos a entender os comandos Git, é
necessário sua instalação e configuração. Neste capítulo veremos
primeiramente como instalar o programa Git em diferentes sistemas
operacionais e posteriormente como configurar algumas opções para
viabilizar e facilitar seu uso.
# Instalação
## Windows
Usuários Windows devem visitar Git for
Windows\footnote{\url{https://git-for-windows.github.io/}}, clicar em
"Download" e baixar o arquivo ".exe".
Após o download, execute o arquivo e você terá a tela conforme figura
\ref{fig:inst01}:
\begin{figure}
\begin{center}
\includegraphics [width=8cm]{./images/inst01.png}
\end{center}
\caption{\textit{Printscreen} do passo 1}
\label{fig:inst01}
\end{figure}
Como de costume, clique em "Next". Para dar continuidade a instalação
aceite a licença do Git.
O diretório apresentado na figura \ref{fig:inst02} vem como default,
porém é possível alterar a instalação para um diretório de sua
preferência. Depois de selecionado o caminho da instalação, clique em
"Next" para prosseguir.
\begin{figure}
\begin{center}
\includegraphics [width=8cm]{./images/inst02.png}
\end{center}
\caption{\textit{Printscreen} do passo 2}
\label{fig:inst02}
\end{figure}
Na tela de componentes (figura \ref{fig:inst03}) podemos definir
atalhos, integração ao menu de contexto do Windows Explorer, associação
de arquivos e uso de font TrueType. O Git Bash é o prompt de comandos
próprio, que além dos comandos Git também fornece alguns comandos Unix
que podem ser bem úteis. Já o Git GUI é uma interface gráfica para
trabalhar com Git. É recomendável a seleção de ambos os itens.
Depois de selecionado os componentes de sua preferência, clique em
"Next" para dar continuidade.
\begin{figure}
\begin{center}
\includegraphics [width=8cm]{./images/inst03.png}
\end{center}
\caption{\textit{Printscreen} do passo 3}
\label{fig:inst03}
\end{figure}
No passo 4, representado pela figura \ref{fig:inst04}, o instalador nos
oferece a oportunidade de mudar o nome da pasta no menu iniciar,
recomenda-se deixar o padrão para fácil localização posteriormente.
\begin{figure}
\begin{center}
\includegraphics [width=8cm]{./images/inst04.png}
\end{center}
\caption{\textit{Printscreen} do passo 4}
\label{fig:inst04}
\end{figure}
Na tela de configuração "PATH environment",conforme a figura
\ref{fig:inst05}, podemos escolher as formas de integração do Git com o
sistema. A primeira opção nos permite usar o Git apenas pelo "Git Bash"
(é o prompt de comando do Git), a segunda opção nos possibilita executar
os comandos no "Git Bash" e no prompt de comando do Windows (cmd.exe), e
a terceira opção é a junção das duas de cima, porém alguns comandos do
Windows serão substituídos por comandos Unix com mesmo nome. Essa
última opção não é recomendada, a primeira opção é a desejável.
\begin{figure}
\begin{center}
\includegraphics [width=8cm]{./images/inst05.png}
\end{center}
\caption{\textit{Printscreen} do passo 5}
\label{fig:inst05}
\end{figure}
Na figura \ref{fig:inst06}, temos a configuração de quebra de linha.
Windows e sistemas Unix (Linux, Mac) possuem formatos diferentes de
quebra de linha em arquivos de texto. Se você escreve um código com
quebras de linha no formato Windows, outra pessoa pode ter problemas ao
abrir o mesmo arquivo em um Linux, e vice-versa. Este passo, portanto,
permite normalizar isso. A primeira opção converte automaticamente os
arquivos para padrão Windows quando receber algum arquivo e converterá
para padrão Unix quando “comitar” (enviar alterações) ao repositório. A
segunda opção, não faz nenhuma conversão ao receber arquivos, mas
convertem para padrão Unix ao “comitar”. Já a terceira opção, o Git não
fará nenhuma conversão. Recomenda-se a seleção da opção "Checkout
Windows-style, commit Unix-Style line endings".
\begin{figure}
\begin{center}
\includegraphics [width=8cm]{./images/inst06.png}
\end{center}
\caption{\textit{Printscreen} do passo 6}
\label{fig:inst06}
\end{figure}
No passo da figura \ref{fig:inst07}, temos a configuração do emulador de
terminal para usar com o Git Bash. A primeira opção utiliza o terminal
MSys2 (Shell), que permite utilizar comandos Unix no Windows. Já a
segunda opção, utiliza o terminal padrão do Windows. Recomendamos a
primeira opção. Feito isso, dê continuidade a instalação.
\begin{figure}
\begin{center}
\includegraphics [width=8cm]{./images/inst07.png}
\end{center}
\caption{\textit{Printscreen} do passo 7}
\label{fig:inst07}
\end{figure}
E por último, a figura \ref{fig:inst08}, que configura ajustes de
performance. Essa opção é para habilitar o sistema de cache de arquivo.
\begin{figure}
\begin{center}
\includegraphics [width=8cm]{./images/inst08.png}
\end{center}
\caption{\textit{Printscreen} do passo 8}
\label{fig:inst08}
\end{figure}
Feito isso, "Next", "Finish" e o Git está instalado.
## Linux
Em qualquer sistema Linux, pode-se utilizar o gerenciador de pacotes da
respectiva distribuição para instalar o Git. Basta executar o código de
instalação de sua respectiva distribuição.
**Debian**
Em uma sessão de terminal Linux de distribuições Debian (Ubuntu, Mint),
execute o código abaixo. Adicione o ppa para obter a versão mais
recente do Git.
```{r, engine="bash", eval=FALSE}
sudo add-apt-repository ppa:git-core/ppa
sudo apt-get update
```
Agora, execute o comando abaixo para instalação do Git. Siga as
instruções do prompt de comando, primeiro confirmando a instalação dos
pacotes e suas dependências, depois confirmando a instalação do pacote
git-core.
```{r, engine="bash", eval=FALSE}
sudo apt-get install git git-core git-man git-gui git-doc \
ssh openssh-server openssh-client
git --version
```
Para adicionar ferramentas complementares, execute:
```{r, engine="bash", eval=FALSE}
sudo apt-get install gitk meld
```
**Arch**
```{r, engine="bash", eval=FALSE}
pacman -S git openssh meld
git --version
```
**Fedora**
```{r, engine="bash", eval=FALSE}
yum install git
git --version
```
Usuários de outra versão do Linux podem visitar Download for
Linux\footnote{\url{https://git-scm.com/download/linux}}.
## MacOS
Existem duas maneiras de instalar o Git no Mac, uma pelo instalador e
outra através do MacPorts.
**Utiizando o Instalador**
O usuário deverá acessar Download for
Mac\footnote{\url{http://git-scm.com/downloads}}, clicar em "Download" e
baixar o arquivo ".dmg".
Após o download, é necessário clicar duas vezes para ter acesso ao
pacote de instalação. Dentro do arquivo ".dmg", execute o arquivo ".pkg"
para iniciar a instalação. Siga os passos até concluir a instalação. É
recomendável utilizar a instalação padrão.
Para testar a instalação, abra o terminal e digite o comando "git". A
saída deverá ser similar a figura \ref{fig:inst09}:
\begin{figure}
\begin{center}
\includegraphics[width=9cm]{./images/inst09.png}
\end{center}
\caption{\textit{Printscreen} do passo 9}
\label{fig:inst09}
\end{figure}
**Utiizando o MacPorts**
A maneira mais fácil de instalar Git no Mac é via
MacPorts\footnote{\url{http://www.macports.org}}, para isso basta
executar o seguinte comando:
```{r, engine="bash", eval=FALSE}
sudo port install git-core
```
# Configurando Perfil
As configurações vão determinar algumas opções globais do Git, sendo
necessário fazê-las apenas uma vez.
## Usuário
Os comandos abaixo vão configurar o nome de usuário e endereço de
e-mail. Esta informação é importante pois é anexada aos commits que
você realiza, ou seja, as configurações ficarão associadas ao trabalho
em desenvolvimento, permitindo que os colaboradores/gestores do projeto
identifiquem suas contribuições. Caso o projeto seja individual, a
importância de configurar usuário e e-mail se mantém. Uma vez que se
trabalha com duas ou mais máquinas, a maneira de identificar a pessoa
que está desenvolvendo o trabalho é pelo nome de usuário.
Em um terminal Bash, execute o código abaixo:
```{r, engine="bash", eval=FALSE}
git config --global user.name "Knight Rider"
git config --global user.email "[email protected]"
```
A opção `--global` usará essa informação para todo projeto Git da
máquina.
É possível fazer definições para cada projeto, ou seja, não globais.
Para isso é necessário executar o comando a seguir sem a opção
`--global`.
```{r, engine="bash", eval=FALSE}
git config user.name "Knight Rider"
git config user.email "[email protected]"
```
Uma vez configurado o perfil, o Git está pronto para uso.
## Atalhos
Os atalhos no Git são chamados de *Alias*. Com ele podemos mapear
comandos que repetidamente usamos para algumas poucas teclas. Estes
atalhos podem ser criados de dois modos: através do comando no terminal
ou editando diretamente no arquivo `/.gitconfig`.
**Pelo terminal:**
Execute o comando abaixo com o atalho de sua preferência e o nome
completo do comando o qual deseja criar o alias.
```{r, engine="bash", eval=FALSE}
git config --global alias.nome_do_alias "comando inteiro"
```
Um exemplo bem simples é o seguinte:
```{r, engine="bash", eval=FALSE}
git config --global alias.st "status"
```
Assim, ao executar git st é o mesmo que executar git status.
Pelo método citado acima, o alias é adicionado automaticamente no seu
arquivo `/.gitconfig`.
**Pelo arquivo `/.gitconfig`:**
Pode-se criar atalhos através de um bloco no seu arquivo de
configuração. Para isso, é necessário localizar o diretório do Git e
adicionar a lista de comandos desejada, como no exemplo:
```{r, engine="bash", eval=FALSE}
[alias]
st = status
ci = commit
br = branch
co = checkout
df = diff
```
Assim que adicionar este bloco com os comandos de sua escolha, ele irá
funcionar imediatamente.
Segue abaixo os caminhos para encontrar o arquivo `/.gitconfig` nos
sistemas operacionais:
+ Windows:
1. `C:\\Pasta_do_seu_projeto\\.git\\config`
2. `C:\\Documents and Settings\\Seu_usuario\\.gitconfig`
3. `C:\\Arquivos de programas\\Git\\etc\\gitconfig`
+ Mac:
1. `/Pasta_do_seu_projeto/.git/config`
2. `/Users/Seu_usuario/.gitconfig`
3. `/usr/local/git/etc/gitconfig`
+ Linux:
1. Crie um arquivo como _sudo_ dentro da pasta etc/ com nome de
gitconfig e coloque os atalhos de sua escolha.
Obs: Os arquivos de configuração do Git não tem extensão.
Não importa o método você utilize, suas configurações sempre ficarão
salvas no arquivo `/.gitconfig`.
## Ignorar Arquivos
Usando o arquivo `.gitignore` podemos ignorar arquivos que não desejamos
versionar no repositório, pode ser feito por projeto e por usuário.
Configurar um arquivo `.gitignore` antes de começar a trabalhar, é
importante, pois evita commits acidentais de arquivos que não deveriam
ir para o seu repositório Git.
**Ignorar Arquivos por Projeto:**
Em todos os projetos que necessitam de um controle de versão há sempre
casos em que arquivos não precisam ser versionados. Para isso é preciso
criar um arquivo `.gitignore` no diretório raiz do projeto, o qual
contém padrões (pattern) que serão ignorados, cada padrão fica em uma
linha como no exemplo:
```{r, engine="bash", eval=FALSE}
$ cat .gitignore
*.[oa]
*~
```
A primeira linha fala para o Git ignorar qualquer arquivo finalizado em
**.o** ou **.a** e a segunda linha ignora todos os arquivos que terminam
com um til **(~)**. Esses padrões podem serem feitos de acordo com a
necessidade de cada projeto.
**Ignorar Arquivos por Usuário (Globalmente):**
Para não precisar criar uma lista de comandos para serem ignorados em
cada projeto, é possível ignorar arquivos em todos os repositórios. Para
isso, basta criar um arquivo `.gitignore` em seu diretório _home_
contendo os padrões os quais deseja ignorar e executar o comando abaixo
no terminal a partir da pasta onde está localizado o arquivo
`.gitignore`:
```{r, engine="bash", eval=FALSE}
git config --global core.excludesfile ~/.gitignore
```
A partir disso, todos os arquivos que estão na lista serão ignorados
pelo usuário.
Finalmente com a instalação, configuração essencial (usuário e e-mail) e
configurações adicionais concluídas, podemos começar a utilizar o Git
para versionar nossos projetos.