Confira 6 scripts que vão facilitar a sua vida quando você estiver trabalhando no git.
Usar scirpts escritos em Bash para o Git de fato faciltam sua vida , enquanto se trabalha nesse repositóio git. Então confira 6 scripts que foram escriutos em bash que facilitarão ( e muito) o seu trabalho no git
1. gitlog
O gitlog imprime uma lista abreviada de patches atuais em relação à versão principal. Ele os imprime do mais antigo para o mais recente e mostra o autor e a descrição, com H para HEAD , ^ para HEAD ^ , 2 para HEAD ~ 2 e assim por diante. Por exemplo:
$ gitlog
----------------------- [recovery25] ---------------------- -
(snip)
11 340d27a33895 Bob Peterson gfs2: drenar a lista ail2 após erros io
10 9b3c4e6efb10 Bob Peterson gfs2: limpa a bagunça glock IAbra em gfs2_create_inode
9 d2e8c22be39b Bob Peterson gfs2: do verificação de erros adequada para a família go_sync de glops
8 9563e31f8bfd Christoph Hellwig gfs2 : utilização page_offset em gfs2_page_mkwrite
7 ebac7a38036c Christoph Hellwig gfs2: não usar buffer_heads em gfs2_allocate_page_backing
6 f703a3c27874 Andreas Gruenbacher gfs2: melhorar mmap gravação vs punch_hole consistência
5 a3e86d2ef30e Andreas Gruenbacher gfs2: alocações multi-sequenciados em gfs2_page_mkwrite
4 da3c604755b0 Andreas Gruenbacher gfs2: corrige o manuseio de fim de arquivo no gfs2_page_mkwrite
3 4525c2f5b46f Instrumentação da placa de Bob Peterson Rafael Aquini
2 a06a5b7dea02 Bob Peterson GFS2: adicione go_get_holdtime ao gl_ops
^
8ba5c5 Bob Peterson gfs2: permite que o rgrps tenha um tempo de espera mínimo
Para saber quais patchs estão em uma ramificação diferente, basta especificar uma ramificação alternativa usando o comando abaixo:
$ gitlog recovery24
2. gitlog.id
O comando gitlog.id irá apenas imprimir os IDs SHA1 do patch:
$ gitlog.id
----------------------- [recovery25] -------------------- ---
56908eeb6940 2ca4a6b628a1 fc64ad5d99fe 02031a00a251 f6f38da7dd18 d8546e8f0023 fc3cc1f98f6b 12c3e0cb3523 76cce178b134 6fc1dce3ab9c 1b681ab074ca 26fed8de719b 802ff51a5670 49f67a512d8c f04f20193bbb 5f6afe809d23 2030521dc70e dada79b3be94 9b19a1e08161 78a035041d3e f03da011cae2 0d2b2e068fcd 2449976aa133 57dfb5e12ccd 53abedfdcf72 6fbdda3474b3 49544a547188 187032f7a63c 6f75dae23d93 95fc2a261b00 ebfb14ded191 f653ee9e414a 0e2911cb8111 73968b76e2e3 8a3e4cb5e92c a5f2da803b5b 7c9ef68388ed 71ca19d0cba8 340d27a33895 9b3c4e6efb10 d2e8c22be39b 9563e31f8bfd ebac7a38036c f703a3c27874 a3e86d2ef30e da3c604755b0 4525c2f5b46f a06a5b7dea02 8ba93c796d5c e8b5ff851bb9
Ele assume a ramificação atual, mas pode se especificar uma diferente caso você deseje .
3. gitlog.id2
O gitlog.id2 é o mesmo que gitlog.id, mas sem a linha de ramificação na parte superior. Isso é útil para escolher todos os patches de um ramo para o ramo atual:
$ # criar uma nova ramificação
$ git branch --track origin / master
$ # verificar a nova ramificação que acabei de criar
$ git checkout recovery26
$ # escolher todos os patches da ramificação antiga para a nova
$ for i no `gitlog .id2 recovery25`; faça git cherry-pick $ i; pronto
4.gitlog.grep
O gitlog.grep solicita uma string dentro dessa coleção de patches. Por exemplo, se eu encontrar um bug e quiser corrigir o patch que tem uma referência à função inode_go_sync , basta fazer faço:
$ gitlog.grep inode_go_sync
----------------------- [recovery25 - 50 patches] ---------------- -------
(snip)
11 340d27a33895 Bob Peterson gfs2: drene a lista ail2 após erros io
10 9b3c4e6efb10 Bob Peterson gfs2: limpe a bagunça do glock iopen em gfs2_create_inode
9 d2e8c22be39b Bob Peterson gfs2: verifique a família de erros para go_syn glops
152: -static void inode_go_sync (struct gfs2_glock * gl)
153: + static int inode_go_sync (struct gfs2_glock * gl)
163: @@ -296,6 +302,7 @@ static void inode_go_sync (struct gfs2_glock * gl)
8 9563e31f8bd Christoph Hellwig gfs2: use page_offset em gfs2_page_mkwrite
7 ebac7a38036c Christoph Hellwig gfs2: não use buffer_heads em gfs2_allocate_page_backing
6 f703a3c27874 Andreas Gruenbacher gfs2: Melhorar mmap gravação vs punch_hole consistência
5 a3e86d2ef30e Andreas Gruenbacher gfs2: alocações multi-sequenciados em gfs2_page_mkwrite
4 da3c604755b0 Andreas Gruenbacher gfs2: FIX EOF manuseamento em gfs2_page_mkwrite
3 4525c2f5b46f Bob Peterson instrumentação laje de Rafael Aquini
2 a06a5b7dea02 Bob Peterson GFS2: adicione go_get_holdtime a gl_ops
^ 8ba93c796d5c Bob Peterson gfs2: introduza a nova função restante_hold_time e use-a no dq
H e8b5ff851bb9 Bob Peterson gfs2: permita que o rgrps tenha um tempo de espera mínimo
Agora sabemos que o patch HEAD ~ 9 é o que precisa ser corrigido. O uso do git rebase -i HEAD ~ 10 é para editar o patch 9, o git commit -a --amend e o git rebase --continue é para fazer os ajustes necessários.
5. gitbranchcmp3
O gitbranchcmp3 me permite comparar minha ramificação atual com outra ramificação, para que eu possa comparar versões mais antigas de patches com minhas versões mais recentes e ver rapidamente o que mudou e o que não mudou. Ele gera um script de comparação (que usa a ferramenta KDE Kompare , que também funciona no GNOME3) para comparar os patches que não são exatamente iguais. Se não houver outras diferenças além dos números das linhas, ele imprimirá [SAME] . Se houver apenas diferenças de comentários, ele será impresso [mesmo] (em letras minúsculas). Por exemplo:
$ gitbranchcmp3 recovery24 Recuperação de
ramificação24 tem 47 patches
Recuperação de ramificação25 tem 50 patches
(snip)
38 87eb6901607a 340d27a33895 [mesmo] gfs2: drena a lista ail2 após erros io
39 90fefb577a26 9b3c4e6efb10 [same] gfs2: clean
up8 mesmo] gfs2: Verificação de erro adequada para a família de glops go_sync
41 2ab662294329 9563e31f8bfd [SAME] gfs2: use page_offset em gfs2_page_mkwrite
42 0adc6d817b7a ebac7a38036c [SAME]
gfs2ing5: gravação vs. consistência punch_hole
44 de57c2f72570 a3e86d2ef30e [SAME] gfs2: alocações de vários blocos em gfs2_page_mkwrite
45 7c5305fbd68a da3c604755b0 [SAME] gfs2: Corrija o manuseio de fim de arquivo em gfs2_page_mkwrite
46 162524005151 4525c2f5b46f [SAME] instrumentação de lajes de Rafael Aquini
47 a06a5b7dea02 []
gFS2: no dq
49 e8b5ff851bb9 [] gfs2: permita que o rgrps tenha um tempo de espera mínimo
Ausente na recuperação25:
O ausente:
compare o script gerado em: /tmp/compare_mismatches.sh
6. gitlog.find
O gitlog.find , é um script para ajudar a identificar onde estão as versões anteriores dos meus patches e o status atual de cada um. Isso é feito combinando a descrição do patch. Ele também gera um script de comparação (novamente, usando o Kompare) para comparar o patch atual com o equivalente do upstream:
$ gitlog.find
----------------------- [recovery25 - 50 patches] ----------------- ------
(snip)
11 340d27a33895 Bob Peterson gfs2: drenar a lista ail2 após erros io
lo 5bcb9be74b2a Bob Peterson gfs2: drenar a lista ail2 após erros io
10 9b3c4e6efb10 Bob Peterson gfs2: limpar a bagunça do glock em
gfsc2bc2cn Bob Peterson gfs2: limpar a bagunça do iopen glock no gfs2_create_inode
9 d2e8c22be39b Bob Peterson gfs2: Verificação de erro adequada para a família de glops go_sync
lo feb7ea639472 Bob Peterson gfs2: Verificação de erro adequada para a família de gl_s
go_sync gops2 gfs2_page_mkwrite
ms f3915f83e84c Christoph Hellwig gfs2: uso page_offset em gfs2_page_mkwrite
7 ebac7a38036c Christoph Hellwig gfs2: não use buffer_heads em gfs2_allocate_page_backing
ms 35af80aef99b Christoph Hellwig gfs2: não use buffer_heads em gfs2_allocate_page_backing
6 f703a3c27874 Andreas Gruenbacher gfs2: Melhorar mmap escrever vs. punch_hole consistência
fn 39c3a948ecf6 Andreas Gruenbacher gfs2: Melhore a gravação do mmap vs. a consistência do punch_hole
5 a3e86d2ef30e Andreas Gruenbacher gfs2: Alocações de vários blocos em gfs2_page_mkwrite
fn f53056c43063 Andreas Gruenbac-
g5s2: gfs2_page_mkwrite
fn 184b4e60853d Andreas Gruenbacher gfs2: Fix EOF manuseio em gfs2_page_mkwrite
3 4525c2f5b46f Bob Peterson instrumentação laje de Rafael Aquini
Não encontrada a montante
2 a06a5b7dea02 Bob Peterson GFS2: Add go_get_holdtime para gl_ops
Não encontrada a montante
^ 8ba93c796d5c Bob Peterson gfs2: introduzir nova função remaining_hold_time e use-o no dq
Não encontrado upstream
H e8b5ff851bb9 Bob Peterson gfs2: permita que o rgrps tenha um tempo de espera mínimo
Não encontrado upstream
Compare o script gerado: /tmp/compare_upstream.sh
Os patches são mostrados em duas linhas, a primeira delas é o patch atual, seguido pelo patch upstream correspondente e uma abreviação de 2 caracteres para indicar seu status upstream:
- O lo significa que o patch está apenas no repositório local do Git upstream (ou seja, ainda não foi enviado a montante).
- O ms significa que o patch está no ramo principal de Linus Torvald.
- O fn significa que o patch é enviado para o ramo de desenvolvimento "for-next", destinado à próxima janela de mesclagem upstream.
Alguns dos scripts fazem suposições com base em como se normalmente trabalha com o Git. Por exemplo, ao procurar os patches upstream, ele usa a localização da minha árvore Git bem conhecida. Portanto, você precisará ajustá-los ou melhorá-los para se adequar às suas condições. O script gitlog.find foi projetado para localizar apenas os patches GFS2 e DLM ; portanto, a menos que você seja um desenvolvedor de GFS2, convém personalizá-lo para os componentes que lhe interessam
Código fonte
Código fonte
Aqui está a fonte desses scripts.
1. gitlog
#! / bin / bash
branch = $ 1
se teste "x $ branch " = x; então
branch = ` git branch -a | grep "*" | cut -d '' -f2 `
fi
patches = 0
tracking = ` git rev-parse --abbrev-ref --symbolic-full-name @ { u } `
LIST = ` git log --reverse --abbrev-commit - -pretty = rastreamento $ on-line.. $ filial | cut -d '' -f1 | colar -s -d '' '
para i em $ LIST ; faça patches = $ ( eco $ patches + 1 | bc ) ; feito
se [ [ $ branch = ~. * para o próximo. * ] ]
então
start = HEAD
# start = origin / for-next
else
start = origin / master
fi
tracking = ` git rev-parse --abbrev-ref --symbolic-full-name @ { u } `
/ usr / bin / echo "------------------- ---- [" $ branch "] ----------------------- "
patches = $ ( eco $ patches - 1 | bc ) ;
para i em $ LIST ; faça
se [ $ patches -eq 1 ] ; então
cnt = "^"
elif [ $ patches -eq 0 ] ; então
cnt = "H"
else
if [ $ patches -lt 10 ] ; então
cnt = " $ patches "
else
cnt = " $ patches "
fi
fi
/ usr / bin / git show --abbrev-commit -s --pretty = formato: " $ cnt % h% <| (32)% an% s% n " $ i
patches = $ ( eco $ patches- 1 | bc )
done
#git log --reverse --abbrev-commit --pretty = formato: "% h% <| (32)% an% s" $ tracking .. $ branch
#git log --reverse --abbrev- commit --pretty = formato: "% h% <| (32)% an% s" ^ origem / mestre ^ linux-gfs2 / for-next $ branch
2. gitlog.id
branch = $ 1
se teste "x $ branch " = x; então
branch = ` git branch -a | grep "*" | cut -d '' -f2 `
fi
tracking = ` git rev-parse --abbrev-ref --symbolic-full-name @ { u } `
/ usr / bin / echo " ---------- ------------- [" $ branch "] ----------------------- "
git log --reverse --abbrev-commit --pretty = on-line $ tracking .. $ branch | cut -d '' -f1 | colar -s -d ''
3. gitlog.id2
#! / bin / bash
branch = $ 1
se teste "x $ branch " = x; então
branch = ` git branch -a | grep "*" | cut -d '' -f2 `
fi
tracking = ` git rev-parse --abbrev-ref --symbolic-full-name @ { u } `
git log --reverse --abbrev-commit --pretty = oneline $ tracking .. $ filial | cut -d '' -f1 | colar -s -d ''
4. gitlog.grep
#! / bin / bash
param1 = $ 1
param2 = $ 2
se teste "x $ param2 " = x; então
branch = ` git branch -a | grep "*" | cut -d '' -f2 `
string = $ param1
else
branch = $ param1
string = $ param2
fi
patches = 0
tracking = ` git rev-parse --abbrev-ref --symbolic-full-name @{ u } `
LIST = ` git log - reverso --abbrev-commit --pretty = oneline $ tracking .. $ branch | cut -d '' -f1 | colar -s -d '' '
para i em $ LIST ; faça patches = $ ( eco $ patches + 1 | bc ) ; done
/ usr / bin / echo "----------------------- [" $ branch "-" $ patches "patches] -----------------------"
patches = $ ( eco $ patches - 1 | bc ) ;
para i em $ LIST ; faça
se [ $ patches -eq 1 ] ; então
cnt = "^"
elif [ $ patches -eq 0 ] ; então
cnt = "H"
else
if [ $ patches -lt 10 ] ;então
cnt = " $ patches "
else
cnt = " $ patches "
fi
fi
/ usr / bin / git show --abbrev-commit -s --pretty = formato: " $ cnt % h% <| (32)% an% s " $ i
/ usr / bin / git show --pretty = email --patch-with-stat $ i | patches grep -n " $ string " = $ ( eco $ patches -
1 | bc )
feito
5. gitbranchcmp3
! / bin / bash
#
# gitbranchcmp3 <ramificação antiga> [<novo_branch>]
#
oldbranch = $ 1
newbranch = $ 2
script = / tmp / compare_mismatches.sh
/ usr / bin / rm -f $ script
echo "#! / bin / bash " > $ script
/ usr / bin / chmod 755 $ script
echo " # Gerado por gitbranchcmp3.sh " >> $ script
echo " # Execute este script para comparar os patches incompatíveis " >> $ script
echo "" >> $ script
echo "função compare_them ()" >> $ script
echo "{" >> $ script
echo "git show --pretty = email --patch-with-stat \ $ 1> / tmp / gronk1 " >> $ script
echo " git show --pretty = email --patch-with-stat \ $ 2> / tmp / gronk2 " >> $ script
echo " kompare / tmp / gronk1 / tmp / gronk2 " >> $ script
echo "}" >> $ script
echo "" >> $ script
se teste "x$ newbranch " = x; então
newbranch = ` git branch -a | grep "*" | cut -d '' -f2 `
fi
tracking = ` git rev-parse --abbrev-ref --symbolic-full-name @ { u } `
declare -a oldsha1s = ( ` git log --reverse --abbrev-commit --pretty = on-line $ tracking .. $ oldbranch | cut -d '' -f1 | paste -s -d '' ' )
declara -a newsha1s = ( ` git log --reverse --abbrev-commit --pretty = oneline $ tracking .. $ newbranch | cut -d ' ' -f1 | cole -s - d '' ` )
#echo" old: "$ oldsha1s
oldcount = $ {# oldsha1s [@]}
echo " O ramo $ oldbranch possui $ patches de
oldcount " oldcount = $ (eco $ oldcount - 1 | bc )
#for o em `seq 0 $ {# oldsha1s [@]}`; do
# echo -n $ {oldsha1s [$ o]} ""
# desc = `git show $ i | cabeça -5 | tail -1 | cut -b5-`#
done
#echo" new: "$ newsha1s
newcount = $ {# newsha1s [@]}
echo " A filial $ newbranch possui patches de $ newcount "
newcount = $ ( echo $ newcount - 1 | bc )
#for o em `seq 0 $ {# newsha1s [@]}`; do
# echo -n $ {newsha1s [$ o]} ""
# desc = `git show $ i | cabeça -5 | tail -1 | cut -b5-`#
done
echo
para novo no ` seq 0 $ newcount ` ; do
newsha = $ {newsha1s [$ new]}
newdesc = ` git show $ newsha | cabeça -5 | cauda -1 | corte -b5- `
oldsha = ""
mesmas = "[]"
para velho no ` SEQ 0 $ oldcount ` ; faça
se teste " $ {oldsha1s [$ old]} " ="partida" ; então
continue ;
fi
olddesc = ` git show $ {oldsha1s [$ old]} | cabeça -5 | cauda -1 | cut -b5- `
se teste " $ olddesc " = " $ newdesc " ; então
oldsha = $ {oldsha1s [$ old]}
#echo $ oldsha
git show $ oldsha | cauda -n + 2 | grep -v "índice. * \. \." | grep -v "@@" > / tmp / gronk1
mostra $ newsha | cauda -n + 2 | grep -v "índice. * \. \." | grep -v "@@" > / tmp / gronk2
diff / tmp / gronk1 / tmp / gronk2 e> / dev / null
se [ $? -eq 0 ] ; então
# Sem diferenças
iguais = "[MESMO]"
oldsha1s [ $ old ] = "partida"
break
fi
git show $ oldsha | sed -n '/ diff /, $ p' | grep -v "índice. * \. \." | grep -v "@@" > / tmp / gronk1
git show $ newsha | sed -n '/ diff /, $ p' | grep -v "índice. * \. \." | grep -v "@@" >
gronk1 / tmp / gronk2 e> / dev / null
se [ $? -eq 0 ] ; then
# Diferenças nos comentários somente
same = "[same]"
oldsha1s [ $ old ] = "match"
break
fi
oldsha1s [ $ old ] = "match"
echo "compare_com $ oldsha $ newsha " >> $ script
fi
done
echo " $ Novo $ oldsha $ Newsha $ mesma $ newdesc "
feito
echo
echo "Falta de $ newbranch :"
the_missing = ""
# Agora percorrer os jovens que não combinaram-se
para o velho em ` seq 0 $ oldcount ` ; fazer
se teste $ { oldsha1s [$ old]} ! = "match" ; então
olddesc = ` git show $ {oldsha1s [$ old]} | cabeça -5 | cauda -1 | corte-b5- `
echo " $ {oldsha1s [$ old]} $ olddesc "
the_missing = ` echo " $ the_missing $ {oldsha1s [$ old]} " `
fi
done
echo " O ausente: " $ the_missing
echo " Compare o script gerado em : $ script "
#git log --reverse --abbrev-commit --pretty = oneline $ tracking .. $ branch | cut -d '' -f1 | colar -s -d ''
6. gitlog.find
#! / bin / bash
#
# Encontre o patch equivalente upstream
#
# gitlog.find
#
cwd = $ PWD
param1 = $ 1
ubranch = $ 2
patches = 0
script = / tmp / compare_upstream.sh
echo "#! / bin / bash" > $ script
/ usr / bin / chmod 755 $ script
echo "# Gerado por gitbranchcmp3.sh" >> $ script
echo "# Execute este script para comparar os patches incompatíveis" >> $ script
echo "" >> $ script
echo "função compare_them ()" >> $ script
echo "{" >> $ script
echo "cwd = $ PWD " >> $ script
echo "git show --pretty = email - patch-with-stat \ $ 2> / tmp / gronk2 " >> $ script
echo " cd ~ / linux.git / fs / gfs2 " >> $ script
echo " git show --pretty = email --patch-with- stat \ $ 1> / tmp / gronk1 " >> $ script
echo "cd $ cwd " >> script $
echo "kompare / tmp / gronk1 / tmp / gronk2" >> $ script
echo "}" >> $ script
echo "" >> $ script
#echo "Reunindo informações do patch upstream. Aguarde."
branch = ` git ramificação -a | grep "*" | cut -d '' -f2 `
tracking = ` git rev-parse --abbrev-ref --symbolic-full-name @ { u } `
cd ~ / linux.
$ {ubranch} " = " X " ; então
ubranch = ` git branch -a | grep "*" | cut -d '' -f2 `
fi
utracking = ` git rev-parse --abbrev-ref --symbolic-full -name @ { u } `
#
# reúna uma lista de patches gfs2 do master, caso não possamos encontrá-lo
#
#git log --abbrev-commit --pretty = format:"% h% <| (32) % an% s "mestre | grep -i -e" gfs2 "-e" dlm ">/ tmp / gronk
git log --reverse --abbrev-commit --pretty = formato: "ms% h% <| (32)% an% s" master fs / gfs2 / > / tmp / gronk.gfs2
# ms = no
log git principal do Linus --reverse --abbrev-commit - -pretty = formato: "ms% h% <| (32)% an% s" master fs / dlm / > / tmp / gronk.dlm
cd $ cwd
LIST = ` git log --reverse --abbrev-commit - bonito = rastreamento on-line $ . $ filial | cut -d '' -f1 | colar -s -d '' '
para i em $ LIST ; faça patches = $ ( eco $ patches + 1 | bc ) ; done
/ usr / bin / echo "----------------------- [" $ branch "-" $ patches "patches] ------- ---------------- "
patches = $ ( eco $ patches - 1 | bc ) ;
para euem $ LIST ; faça
se [ $ patches -eq 1 ] ; então
cnt = "^"
elif [ $ patches -eq 0 ] ; então
cnt = "H"
else
if [ $ patches -lt 10 ] ; então
cnt = " $ patches "
else
cnt = " $ patches "
fi
fi
/ usr / bin / git show --abbrev-commit -s --pretty = format: " $ cnt % h% <| (32)% an% s" $ i
desc = `/ usr / bin / git show --abbrev-commit -s - bonito = formato: "% s" $ i `
cd ~ / linux.git
cmp = 1
up_eq = ` git log - reverso --abbrev-commit --pretty = formato: "lo% h% <| (32)% um% s " $ utracking .. $ ubranch | grep " $ desc "`
# lo = no local para o próximo
if test " X $ up_eq " = " X " ; então
up_eq = ` git log --reverse --abbrev-commit --pretty = formato: " mestre fn% h% <| (32)% an% s " .. $ utracking | grep " $ desc " `
# fn = na próxima janela de mesclagem
se teste " X $ up_eq " = " X " ; então
up_eq = ` grep " $ desc " / gronk.gfs2 `
se teste " X $ up_eq " = " X " ; em seguida,
up_eq = ` grep " $ desc " / tmp / gronk.dlm `
se teste "X $ up_eq " = "X" ; em seguida,
up_eq = "Não encontrado upstream"
cmp = 0
fi
fi
fi
fi
echo " $ up_eq "
; então
UP_SHA1 = ` echo $ up_eq | cut -d '' -f2 `
echo " compare_com $ UP_SHA1 $ i " >> $ script
fi
cd $ cwd
patches = $ ( echo $ patches - 1 | bc )
done
echo " Compare script gerado: $ script "
Fonte
Até a próxima !
Nenhum comentário:
Postar um comentário