#language pt

== Tutorial - realizar nossa primeira alteração ==

''(This page in English: [[TutorialFirstChange]])''

''(Esta página é a parte 4 de 9 da série [[BrazilianPortugueseTutorial]]. A parte anterior é [[BrazilianPortugueseTutorialHistory]], a próxima parte é [[BrazilianPortugueseTutorialShareChange]])''

Prosseguindo a partir de BrazilianPortugueseTutorialHistory, nós estamos dentro de nosso repositório `my-hello` que clonamos em BrazilianPortugueseTutorialClone.

É uma boa prática no desenvolvimento com o Mercurial isolar cada mudança em um [[Repository|repositório]] separado (veja também [[WorkingPractices]]).  Isso evita que código não-relacionado se misture, e facilita o teste em separado de partes individuais do trabalho.  Vamos prosseguir de acordo com esse modelo.

Nosso tolo objetivo é fazer com que o programa "hello, world" imprima outra linha de saída.  Em primeiro lugar, nós criamos um novo repositório chamado `my-hello-new-output`, um clone de `my-hello`, para nosso pequeno projeto:

{{{
$ cd ..
$ hg clone my-hello my-hello-new-output
updating working directory
2 files updated, 0 files merged, 0 files removed, 0 files unresolved
}}}

Note que demos um nome descritivo para nosso novo repositório, basicamente identificando o propósito do repositório.  Já que no Mercurial a criação de um [[Clone|clone]] de um repositório é uma operação barata, nós rapidamente iremos acumular muitos repositórios ligeiramente diferentes.  Se nós não dermos a eles nomes descritivos, rapidamente perderemos a capacidade de diferenciá-los (veja RepositoryNaming).

Agora é o momento de fazer uma mudança no novo repositório.  Vamos entrar no [[WorkingDirectory|diretório de trabalho]], que é simplesmente o nome que damos para o diretório onde estão todos os arquivos, e modificar o código fonte com nosso editor favorito:

{{{
$ cd my-hello-new-output
$ vi hello.c
}}}

O conteúdo de `hello.c` inicialmente é:

{{{#!cplusplus numbers=off
/*
 * hello.c
 *
 * Placed in the public domain by Bryan O'Sullivan
 *
 * This program is not covered by patents in the United States or other
 * countries.
 */

#include <stdio.h>

int main(int argc, char **argv)
{
        printf("hello, world!\n");
        return 0;
}
}}}

Vamos editar a função `main` para que ela mostre uma linha extra de saída:

{{{#!cplusplus numbers=off
(...)

int main(int argc, char **argv)
{
        printf("hello, world!\n");
        printf("sure am glad I'm using Mercurial!\n");
        return 0;
}
}}}

Assim que terminamos, fechamos nosso editor favorito, e está feito.
A edição está agora pronta para criarmos uma [[ChangeSet|revisão]].

Mas e se interrompermos nosso trabalho, e esquecermos quais mudanças farão parte da revisão quando a criarmos?
Para verificar quais arquivos foram modificados nós usamos o comando `status}`:

{{{
$ hg status
M hello.c
}}}

A saída é compacta, mas o prefixo `M` está meramente nos dizendo que `hello.c` foi modificado, então nossa mudança está pronta para ser incluída em uma revisão.

Ao invés da forma longa `hg status` podemos alternativamente digitar apenas `hg st`: o Mercurial suporta abreviação de comandos,
bastando apenas que os caracteres digitados formem um prefixo distinto de um comando.

{{{
$ hg st
M hello.c
}}}

Nós também podemos examinar as mudanças em si que fizemos no arquivos usando o comando `diff`:

{{{
$ hg diff
diff -r 82e55d328c8c hello.c
--- a/hello.c   Fri Aug 26 01:21:28 2005 -0700
+++ b/hello.c   Mon May 05 00:27:56 2008 +0200
@@ -12,5 +12,6 @@
 int main(int argc, char **argv)
 {
        printf("hello, world!\n");
+       printf("sure am glad I'm using Mercurial!\n");
        return 0;
 }
}}}

<!> No caso de querermos descartar nossas mudanças e começar novamente,
podemos usar o comando `revert` para restaurar `hello.c` para seu estado sem modificações
(ou usar a opção `--all` para restaurar todos os arquivos).
Apenas esteja certo de que é isso que você realmente quer fazer (veja [[Revert]]).

{{{
$ hg revert hello.c
}}}

`revert` renomeia o arquivo `hello.c` modificado para `hello.c.orig` e restaura `hello.c` para seu estado não modificado original.

`status` agora lista `hello.c.orig` como não rastreado (prefixo "?").

{{{
$ hg st
? hello.c.orig
}}}

Se mudarmos de idéia novamente e quisermos reaproveitar a modificação que fizemos,
basta removermos o arquivo `hello.c` sem modificações e renomearmos de volta o `hello.c.orig` para `hello.c`:

{{{
$ rm hello.c
$ mv hello.c.orig hello.c
$ hg st
M hello.c
}}}

O ato de criar uma revisão é chamado [[Commit|consolidação]] (''committing'', em inglês).
Nós fazemos uma consolidação através do comando `commit`.
Esse comando possui um nome curto alternativo: `ci` (do inglês "check in"),
então podemos usar:

{{{
$ hg ci
}}}

Isso irá abrir o editor de texto padrão, e apresentar algumas linhas de texto.

''Nota:'' O editor de texto padrão em um Unix é o `vi`. Isso pode ser alterado usando as variáveis de ambiente {{{EDITOR}}} ou [[HGEDITOR]].

{{{

HG: Enter commit message.  Lines beginning with 'HG:' are removed.
HG: --
HG: user: mpm@selenic.com
HG: branch 'default'
HG: changed hello.c
}}}

A primeira linha é vazia, e as linhas que se seguem identificam o usuário, nome de ramo e os arquivos que irão incorporar esta revisão.

O nome de ramo padrão é "default" (veja NamedBranches).
O valor padrão para "user" é lido do arquivo de configuração `~/.hgrc`,
seção "ui", valor "username"
(veja [[http://www.selenic.com/mercurial/hgrc.5.html#ui|hgrc(5)]]). Alternativamente,
ele pode ser especificado na linha de comando com a opção -u (veja `hg help ci`
ou [[http://www.selenic.com/mercurial/hg.1.html#commit|hg.1.html#commit]]).

Para consolidar esta revisão, nós devemos descrever seu propósito (veja [[ChangeSetComments]]).  Vamos digitar algo assim:

{{{
Express great joy at existence of Mercurial
HG: Enter commit message.  Lines beginning with 'HG:' are removed.
HG: --
HG: user: mpm@selenic.com
HG: branch 'default'
HG: changed hello.c
}}}

Em seguida, nós salvamos o texto e fechamos o editor, e se tudo correr bem, o comando `commit` irá terminar sem imprimir nada.

<!> Se você fechar o editor sem salvar o texto, `commit` irá abortar a operação, de modo que você pode mudar de idéia antes da consolidação.

Vejamos o que o comando `status` vai nos dizer agora:

{{{
$ hg st
}}}

Nada! Consolidamos nossa mudança para uma revisão, de modo que não há arquivos modificados.
Nossa [[Tip|tip]] agora combina com o conteúdo de nosso diretório de trabalho.

O comando [[Parent|parents]] nos mostra que o diretório de trabalho de nosso repositório está agora
em sincronia (veja [[Update]]) com a nova revisão consolidada.
(aqui temos apenas uma revisão pai, o que é sempre o caso após uma consolidação.
Nós veremos o caso de dois pais em BrazilianPortugueseTutorialMerge):

{{{
$ hg par
changeset:   2:86794f718fb1
tag:         tip
user:        mpm@selenic.com
date:        Mon May 05 01:20:46 2008 +0200
summary:     Express great joy at existence of Mercurial
}}}

Aí está!  Nós consolidamos uma revisão.

Nós podemos agora podemos examinar o histórico de mudanças do nosso novo trabalho:
{{{
$ hg log
changeset:   2:86794f718fb1
tag:         tip
user:        mpm@selenic.com
date:        Mon May 05 01:20:46 2008 +0200
summary:     Express great joy at existence of Mercurial

(...)
}}}

'''Nota:''' Naturalmente o usuário, data e [[ChangeSetID|ID de revisão]] irão variar.

Como discutimos em [[BrazilianPortugueseTutorialClone]], a nova revisão existe apenas neste repositório.  Esse é um aspecto muito importante do modo como o Mercurial opera.

Para ver como compartilhar mudanças, prossigamos para BrazilianPortugueseTutorialShareChange.

----
CategoryBrazilianPortuguese