advanced git commands
Este tutorial explora comandos Git úteis, como Git Stash, Git Reset, Git Cherry Pick, Git Bisect e explica como integrar o GitHub ao Jira:
Em nossos tutoriais anteriores desta série, vimos a maioria dos recursos do GitHub.
Neste tutorial, veremos o seguinte:
- Criação de lançamentos
- Integração com Atlassian Jira
- Comandos Git mais comumente usados para desenvolvedores
- Git Stash
- Git Cherry Pick
- Git Reset
- Git Bisect
=> Dê uma olhada no guia do GitHub aqui.
arrays c ++ em funções
O que você aprenderá:
- Criação de lançamentos
- Integração do GitHub com Jira
- Comandos Git avançados para desenvolvedores
- Conclusão
- Leitura recomendada
Criação de lançamentos
Versões no GitHub são usadas para empacotar seu software, adicionar notas de versão e binários (arquivos WAR, EAR, JAR) para clientes e pessoas usarem os mesmos.
Para criar um Release, acesse a página principal do repositório e clique no botão Lançamentos guia sob Gerenciar tópicos.
Clique em Crie uma nova versão.
Forneça uma tag e um título de liberação. Os binários também são adicionados à versão. Quando terminar, clique em Publicar lançamento.
O lançamento agora está pronto com o código-fonte e binários.
Integração do GitHub com Jira
Um dos aspectos de rastreabilidade importantes é fazer referência ao problema Jira com os commits no GitHub. O GitHub pode ser integrado ao Jira não apenas para fazer referência ao problema, mas também para ajudar a criar branches e Pull Request de dentro do Jira.
Normalmente, quando o desenvolvedor começa a trabalhar na tarefa ou nos bugs, um branch é criado por ele. Poste o desenvolvimento ou resolva os bugs, uma solicitação pull pode ser criada a partir do Jira para mesclar com o principal mestre filial. O branch criado pelo desenvolvedor pode então ser excluído.
Para configurar a integração, usamos um plugin Integração Git para Jira. Este é um plugin comercial. O plugin pode ser baixado de Aqui
Instale o plugin no Jira de Admin -> Complementos.
Assim que o plugin for instalado, vá para Aplicativo -> Repositórios Git e conecte-se ao GitHub.
Digite o nome de usuário e a senha do GitHub. Clique Conectar .
Os repositórios mencionados para a conta do usuário serão exibidos. Clique em Importar Repositórios para finalizar a configuração da integração.
Compromisso GitHub com problema de Jira
Como parte da mensagem de confirmação, digite como mostrado abaixo. Clique em Confirmar as alterações .
Exemplo 1: Abaixo está um exemplo de Smart Commit que permite que os desenvolvedores executem ações nos problemas do Jira a partir da mensagem de confirmação. Um desses comandos é o #Comente junto com a chave de problema que adiciona o comentário ao problema de Jira, conforme mostrado abaixo.
Seção de comentários atualizada.
Exemplo 2: Atribuir a um usuário e atualizar o tempo gasto como 4 h.
Use o #atribuir e #Tempo comando de confirmação inteligente na mensagem de confirmação.
Ambas as ações foram concluídas.
Exemplo 3: Altere o status do problema para Em andamento .
Criar uma filial
Conforme as tarefas e os bugs são atribuídos aos desenvolvedores, eles precisam começar a trabalhar no desenvolvimento. Para isso, eles criam um branch para o problema no qual estão trabalhando, realizam as atividades de desenvolvimento e levantam uma solicitação pull para mesclar no branch master.
Na edição Jira na parte inferior, clique em Criar filial.
Clique em Crie uma filial.
No GitHub, faça uma alteração no arquivo no branch criado acima e envie o mesmo.
À medida que o desenvolvimento é concluído, o usuário pode gerar uma Solicitação Pull de Jira.
Na parte inferior da edição, clique em Criar solicitação de pull.
Clique em Crio. O Pull Request será mostrado como Open.
A próxima etapa é mesclar a solicitação pull no GitHub.
O status é atualizado de acordo no Jira.
Comandos Git avançados para desenvolvedores
Nesta última seção, veremos alguns dos comandos Git comumente usados para desenvolvedores. Nada a ver com o GitHub, mas ajudará os desenvolvedores antes de enviarem as alterações para o GitHub.
Git Stash
Na maioria dos cenários do projeto, quando você está trabalhando em um novo recurso ou aprimoramento, repentinamente seria necessário trabalhar em um defeito urgente que foi relatado e é um obstáculo. Como você está no meio do caminho em seu novo trabalho e não o concluiu, não há nenhum ponto em comprometer as alterações que estão feitas pela metade.
Portanto, é melhor suspender ou salvar o trabalho parcialmente concluído temporariamente, corrigir o bug e voltar a trabalhar no novo recurso ou aprimoramento. Git stash fornece uma solução para isso. Você pode alternar facilmente o contexto de fazer alterações rapidamente.
Exemplo 1 :Suponha que você esteja trabalhando em uma tarefa atribuída a você e, quando você olha para o status, mostra que não está monitorado no momento.
De repente, há um bug de alta prioridade atribuído a você. Portanto, precisamos salvar temporariamente ou esconder o trabalho em que estamos trabalhando.
Execute o seguinte comando.
git stash save “Mensagem”
Neste momento, o diretório de trabalho está limpo. Quaisquer novos commits podem ser feitos e se houver bugs, você pode mudar o branch para trabalhar nisso, etc.
Quando você quiser reaplicar as alterações de onde você deixou, use o comando.
git stash pop
O comando acima removerá o stash da lista e aplicará o último estado salvo.
Você também pode usar:
git stash aplicar
O comando acima manterá as alterações no estoque e não as removerá.
Agora as alterações são reaplicadas e você pode confirmá-las.
Exemplo 2: Esconda suas mudanças, mude de branch e junte as mudanças.
Faça a alteração no arquivo Html no mestre mudanças de branch e stash.
O próximo é mudar para o erro branch, faça mudanças e submeta mudanças.
git checkout -b bug
Faça alterações no arquivo Html.
git commit -a -m “Corrigido problema de email”
Volte para o mestre ramificar e reaplicar as alterações do estoque.
Agora junte-se a erro ramo para o mestre filial. Confirme as alterações após a fusão.
Exemplo 3: Trabalhando com Multiple Stash.
No repositório local, existem 2 arquivos Html. Portanto, é possível que vários desenvolvedores trabalhem em vários arquivos e armazenem as alterações conforme necessário para trabalhar nas solicitações urgentes que chegam para corrigir as alterações.
O Desenvolvedor 1 funciona em hello.html e o Desenvolvedor 2 funciona em index.html.
Desenvolvedor 1
A lista do estoque tem 1 entrada agora.
Desenvolvedor 2
A lista de armazenamento agora tem 2 entradas. O último stash é o primeiro na pilha, que é stash @ {0}. Agora ambos os desenvolvedores podem fazer qualquer outro commit urgentemente ou trabalhar em algum outro branch e então voltar para o mestre branch e aplique as mudanças de stash.
Para aplicar o estoque mais recente, você pode apenas executar
git stash pop
Para aplicar um estoque específico na pilha, execute o seguinte comando.
git stash pop stash @ {1}
Vamos aplicar o segundo estoque que é esconder @ {1}
Da mesma forma, o outro stash pode ser aplicado.
Git Cherry Pick
Hoje, os desenvolvedores trabalham em vários ramos, como recurso, aprimoramento, bug, etc.
Existem situações onde apenas alguns commits específicos precisam ser selecionados e não mesclar o branch inteiro em outro branch. Isso é chamado de Cherry Pick. Este processo permite que você escolha arbitrariamente qualquer commit do Git de outras ramificações e acrescente-o ao HEAD atual da árvore de trabalho.
Exemplo 1:
No repositório git local, temos os 6 arquivos a seguir.
Um arquivo é excluído, digamos arquivo5.txt.
Comprometa as mudanças.
Olhe o log agora. Arquivo5.txt é excluído.
Portanto, queremos selecionar o commit onde adicionamos arquivo5.txt. Precisamos encontrar o ID de commit de file5.tx e executar o comando.
escolha a cereja do bolo
Neste caso, o ID de confirmação de quando o arquivo5.txt foi adicionado é a2f0124
File5.txt foi restaurado. Nós escolhemos o commit.
Exemplo 2:
Vamos apenas modificar arquivo6.txt e comprometer as mudanças no mestre filial.
Olhe para a segunda linha em arquivo6.txt onde o e-mail não está especificado corretamente.
Crie um branch de bug e corrija o problema. Ao mesmo tempo, modifique o arquivo5.txt também para que tenhamos vários commits feitos no branch do bug, mas escolheremos apenas o commit feito em file6.txt.
Arquivo 6 modificado em erro filial.
Portanto, no geral, fizemos mudanças em arquivo5 e arquivo6 no ramo Bug.
Agora vamos voltar para o mestre branch e Cherry-Pick o commit feito apenas para file6.txt.
Como você pode ver, em vez de fundir o erro ramificar para o mestre branch, selecionamos apenas um commit específico e aplicamos no branch master.
Git Reset
O Git reset é um comando poderoso para desfazer mudanças locais. Portanto, para desestabilizar todos os arquivos testados, este comando é usado.
Exemplo
Modifique um arquivo e adicione-o à preparação. Redefina usando o comando conforme mostrado quando as mudanças em estágios não estão em estágio.
Parâmetros de git reset comando.
-suave: Este parâmetro irá apontar o HEAD para outro commit. Todos os arquivos são alterados entre o HEAD original e o commit será testado. O diretório de trabalho está intacto.
Observe a localização HEAD atual.
Vamos voltar 5 commits na história.
Comprometa novamente as alterações.
-misturado: A opção é semelhante ao parâmetro soft. Normalmente, quando há alguns commits ruins, você os remove e corrige mais tarde e comete de volta. Então, essencialmente, precisamos adicionar ao índice usando git add e então git commit. As alterações são deixadas na árvore de trabalho.
Vamos voltar 2 commits na história e ver se os arquivos não foram rastreados.
Agora adicione os arquivos ao teste e confirme as alterações.
-Difícil: Este parâmetro irá parar em um ponto onde um arquivo específico existia. As mudanças não estarão disponíveis na árvore de trabalho.
Olhando para o log acima, vamos voltar ao ponto onde apenas o arquivo 1 foi confirmado, ou seja, a última entrada.
Usando git reset –hard
Git Bisect
Encontre o commit exato que quebrou o código (todos somos humanos, afinal). Freqüentemente, durante o teste do aplicativo, ouvimos de nossos testadores que há um bug ou o recurso está quebrado e você, como desenvolvedor, dirá que funcionou na semana passada. Então, o que aconteceu e por que esse bug apareceu?
Às vezes, uma mudança no outro código pode ter impactado seu recurso. Você tem que gastar tempo percorrendo a história onde há muitos commits que consomem tempo e são difíceis de rastrear quais mudanças causaram a quebra do código.
Git Bisect é o comando para encontrar o commit exato quando o bug foi introduzido. Com o Git bisect, você precisa escolher dois commits, um bom e um ruim. Na metade do caminho entre os dois commits será verificado. Você verifica cada commit ruim ou bom até que o commit que causou a falha do bug ou código seja encontrado.
Exemplo:
- Crie um novo repositório git local e crie um arquivo chamado index.html
- Conteúdo inicial do arquivo conforme mostrado.
- Adicione ao teste e confirme ao repositório.
- Crie um histórico de commits conforme mostrado, para que possamos escolher entre commits bons e ruins. Agora que o commit inicial é feito, faça as outras mudanças conforme mostrado e faça o commit. No geral, faremos 7 commits.
Segunda Mudança
Terceira Mudança
Quarta Mudança
Quinta Mudança
Sexta Mudança
Sétima Mudança
Vamos parar aqui. Portanto, temos sete commits.
Se você olhar a página Html, as linhas após “Todos os 4 eventos…“ estão erradas e, portanto, a documentação não está correta. Portanto, precisamos encontrar o commit onde o erro foi introduzido para que possamos descansar nosso HEAD nesse commit.
Vamos olhar o log e descobrir o mau e bom compromisso.
O commit mais recente não está certo, então pode ser um commit ruim. O commit foi introduzido após o terceiro commit, então podemos ter o Terceira Mudança como o bom commit.
O processo de bissecção começa com git bisect start e termina com git bisect reset.
git bisect bad // Como último commit é ruim. Não há necessidade de fornecer o ID do commit.
git bisect bom
Agora você pode ver que o HEAD está agora entre a metade do commit ruim e bom.
Olhe o conteúdo de index.html e veja se há um bom commit. Caso contrário, o erro ainda não foi encontrado.
Não é que o erro ainda exista. A última linha está errada. Então, nós corremos ‘ git bisect bad ’. Ainda há um commit ruim e o conteúdo atual não é aceitável.
O conteúdo acima é correto e aceitável.
Execute 'git log –oneline' e 'git bisect good'.
Então o Quinta Mudança foi o primeiro mau commit e realmente foi. O erro é identificado.
O conteúdo atual deve estar na documentação final.
À medida que o commit ruim é identificado, você pode informar ao desenvolvedor para corrigir as alterações que podem ser para redefinir o cabeçalho para a quarta alteração que foi o último commit bom.
Corre ' git bisect reset 'Para encerrar o processo.
Conclusão
Neste manual prático do GitHub, tentamos cobrir tudo o que um desenvolvedor precisa para trabalhar, ou seja, do controle de versão e do ponto de vista do rastreamento.
Nos primeiros três tutoriais da série GitHub, aprendemos sobre atividades de controle de versão, criação de repositórios, solicitação de pull, branches, revisões de código, organizações e equipes, bifurcação de repositório, rótulos, marcos, problemas, painéis de projeto, wikis, lançamentos, integração com Jira e alguns comandos Git comumente usados para desenvolvedores.
Esperamos sinceramente que todos os desenvolvedores considerem essa abordagem prática para o GitHub e os comandos Git úteis em seus projetos.
=> Leia a série de treinamento Easy GitHub.
Leitura recomendada
- Tutorial de integração do GitLab Jira
- Comandos Unix: Comandos Unix básicos e avançados com exemplos
- Integração do Selenium com GitHub usando Eclipse
- Tutorial de integração de JIRA e SVN
- Git vs GitHub: explore as diferenças com exemplos
- Tutorial Cucumber Selenium: Cucumber Java Selenium WebDriver Integration
- Tutorial do GitHub para desenvolvedores | Como usar o GitHub
- Tutorial de Pipes Unix: Pipes em Programação Unix