Clipper On Line • Ver Tópico - Tutorial básico do GIT
Página 1 de 4

Tutorial básico do GIT

MensagemEnviado: 18 Jun 2015 20:34
por JoséQuintas
O GIT é interessante pra usarmos na pasta de fontes.
É um controle de versões de arquivos, com opções diversas.

Vamos ao básico, o que já é de muita ajuda

Nota: pra quem acha que parece... não apenas parece, "É" o mesmo software que geralmente usamos pra baixar fontes do github

Aonde encontrar:
https://git-scm.com/

Após instalar, vai ver uma nova opção no menu de contexto do Windows.
É obrigatório estar em uma pasta, seja qual for.
Clique da direita, está lá nas opções: Git GUI Here
gitgui1.png


E ao selecionar, aparece esta tela:
gitgui2.png


Clica em criar novo repositório:
gitgui3.png


E digita o nome da pasta, ou seleciona no explorar.
A tela que vai aparecer é a seguinte, vai ser a sua tela de trabalho com o git.
gitgui4.png

Tutorial básico do GIT

MensagemEnviado: 18 Jun 2015 20:50
por JoséQuintas
Pra facilitar e não ter que marcar um por um, dá pra usar a opção de tudo de uma vez, pelo menos como ponto de partida.
gitgui5.png


Ao fazer isso, os arquivos vão pra lista de baixo.
gitgui6.png


Como é a primeira vez, isto é muito importante:
Tudo que acrescentar vai passar a fazer parte do backup e controle de versão.
Então coloque apenas o que interessa.

Ou adicione um por um, clicando em cada um, ou acrescente tudo, e retire o que não interessa da lista de baixo, basta clicar também.

Estando tudo ok, coloque um texto de sua preferência, e clique em salvar revisão.
gitgui7.png


Pronto.
Configuração inicial completa.
Pode fechar tudo que a configuração está pronta.

Com isso, foi criado na pasta indicada a pasta ".GIT", que vai conter tudo que precisa.
Qualquer coisa, só apagar essa pasta, caso mude de idéia sobre usar ou não o GIT.

No momento, a pasta ".GIT" contém a versão inicial dos arquivos.
Nada na sua pasta foi alterado, ela apenas contém uma cópia de tudo como ponto de partida.

Tutorial básico do GIT

MensagemEnviado: 18 Jun 2015 21:04
por JoséQuintas
Agora abri meu editor favorito, com um fonte horrível por sinal, apenas pra demonstrar.
Seria o trabalho normal do dia a dia: abrir um fonte pra fazer alteração.
gitgui8.png


Fiz pequenas alterações, só pra facilitar no que vém depois.
gitgui9.png


Pode trabalhar o dia inteiro, e mexer em fontes o dia inteiro.
Aqui apenas pra demonstrar, só mexi um pouco, num único fonte.

Só apaguei alguns comentários inúteis.

Tutorial básico do GIT

MensagemEnviado: 18 Jun 2015 21:10
por JoséQuintas
E ao abrir o Git GUI novamente.... voilá....

gitgui10.png


Ele está comparando todos os arquivos atuais com os que foram salvos anteriormente, e mostrando o que está diferente.

No caso aqui é um fonte, e o arquivo de backup que foi criado.

(-) equivale a linha retirada/modificada
(+) equivale a linha acrescentada/atualizada

Só aqui, já te ajuda a revisar as alterações que fez, pra confirmar se era isso mesmo.

Tutorial básico do GIT

MensagemEnviado: 18 Jun 2015 21:31
por JoséQuintas
gitgui11.png


Agora você decide:
Quer considerar concluído, e já atualizar seu "backup", colocando texto e salvar revisão.
Ou quer que faça parte da revisão anterior...

No final, é clicar em salvar revisão.
A próxima revisão vai ser a partir do que salvar agora.
Se não salvar, na próxima vez vão constar estas alterações e as próximas que fizer.

Isso é só a parte básica:
Neste momento você passa a ter backup dos fontes
Além disso, backups em cada ponto em que salvou revisão
Além disso, pode retornar os fontes, para a revisão que quiser - voltar atrás para a posição salva que quiser
E por aí vai.

Se apagar todos os fontes da pasta, menos a pasta ".GIT", vai poder retornar todos os fontes anteriores (a última posição salva).

É isso. Um controle de versões.

Por enquanto não encontrei outras opções no modo visual.
Por exemplo, eu queria ver a lista das revisões.

Mas o básico, já é de muuuuita ajuda.

Valem os mesmos comandos usados nos fontes do Harbour, quando baixados pelo GIT.
Voltar a uma determinada revisão, voltar todos os fontes caso tenha apagado por descuido, etc.

Nota:
Neste uso, o "enviar" não é usado. Para isso, teria que ter algum repositório configurado como matriz, que poderia ser outra máquina ou até na internet.
Não cheguei nessa parte ainda, mas não sei se vou tão fundo nisso.
Uma vez que a pasta ".GIT" contém tudo, acho que ao copiar HDs aqui, já é suficiente - vai ser um backup não só atual, mas de cada uma das revisões.

Nota2:
É por isso que baixar fontes do Harbour pelo Git HUB ocupa bastante espaço, e tem arquivos ".git".
É que está sendo baixada toda a "história" do Harbour, desde o último fechamento que foi a 3.0. (se for a oficial).
E poderíamos posicionar os fontes pra qualquer revisão, até mesmo no ponto considerado como zero.

Tutorial básico do GIT

MensagemEnviado: 18 Jun 2015 22:14
por JoséQuintas
Achei...

gitgui12.png


gitgui13.png


Na primeira janela, mostrando cada uma das revisões.
É como um mapa geral, de todas as revisões.
Na primeira, tudo foi alteração, porque antes estava vazio.

Tutorial básico do GIT

MensagemEnviado: 18 Jun 2015 22:31
por JoséQuintas
Mostra três posições...
Clicando na segunda, mostra o fonte com as alterações que já citei acima, ref. retirar observações

gitgui15.png


E clicanco na última, alterações que fiz depois pra teste.

gitgui14.png


Ou seja, controle total dos fontes, com visão geral de tudo que foi mexido em todas as revisões.

Só pra lembrar, apesar de não mostrado aqui, dá pra retornar pra qualquer uma dessas revisões.
Se fez coisa errada nos fontes.... dá pra desfazer...

Só pra constar:
Git GUI é apenas uma interface visual para o programa Git.
É possível que não possua todas as opções disponíveis via prompt.

Tutorial básico do GIT

MensagemEnviado: 18 Jun 2015 22:44
por JoséQuintas
Durante os testes, acabei mexendo aqui.

gitgui16.png


Suponho que seja pra "fechar" uma versão.

Isso explica porque no mapa haviam duas opções com destaque em verde, porque representam os pontos de fechamento.
Tipo... vai alterando/salvando um sped contábil, até que finalmente libera, e marca como 'fechado".
Uma referência a mais pra facilitar localização de alterações.

Tutorial básico do GIT

MensagemEnviado: 20 Jun 2015 19:28
por JoséQuintas

Tutorial básico do GIT

MensagemEnviado: 20 Jun 2015 20:04
por JoséQuintas
Talvez tenha faltado esclarecer um ponto:

Isso de salvar revisão, ele mexe somente na pasta .GIT, e não na pasta de trabalho.

Mas no caso de pedir pra restaurar/posicionar em determinada revisão, nesse caso a pasta é modificada.
É como restaurar um backup de determinada data.
Mesmo "restaurando" determinada data, a pasta GIT ainda contém todas as revisões, inclusive a mais atualizada.
Então cuidado, antes de testar esse recurso.
Saiba que não perdeu nada, mas tem que saber o comando pra voltar à posição atual.

Então, num "grosso modo", copiar a pasta .GIT é o mesmo que copiar todos os backups de todos os tempos.
E ocupando menos espaço do que ocupariam todos os backups isolados.

Tutorial básico do GIT

MensagemEnviado: 20 Jun 2015 20:16
por sygecom
José, parabéns mais uma vez.
Tutorial de fácil entendimento e de utilidade muito grande para qualquer programador, muito bom.

Tutorial básico do GIT

MensagemEnviado: 20 Jun 2015 22:12
por JoséQuintas
Obrigado.

Acabo de achar uma pequena falha no GIT.
Nem sei se dá pra considerar assim.

Como tenho backup de fontes desde 2008, comecei a montar a história de 7 anos no git.
E em 2009, houve uma mudança onde um diretório chamado PG desapareceu, e depois apareceu um arquivo PG.
Com isso o GIT deu erro.
Provavelmente ele foi comparar diretório com arquivo, e não dá.
Só apaguei o PG da pasta e recarreguei.

É que o git não controla apenas a pasta definida, mas tudo que estiver dentro dela, inclusive subpastas.

Como minha pasta FONTES contém subpastas...

Estou encontrando pontos interessantes, que nem lembrava, como ter usado DLLs em clipper por volta de 2009.

Tutorial básico do GIT

MensagemEnviado: 20 Jun 2015 22:23
por JoséQuintas
Talvez ajude pra exclarecer mais sobre o git....

Tenho o backup de fontes, o primeiro de cada mês.
Descompacto pra pasta do GIT, entro no GIT gui, marco o que foi alterado e salvo, e depois apago tudo.
E estou repetindo isso pra cada backup.

fotogit.png


Então é apagar tudo (menos .git) e salvar o backup de outra data.
Como o git analisa diferenças (não é um programa residente que fica vigiando) dá tudo certo.

fotogir2.png


Isto mostra claramente que a pasta .GIT contém tudo equivalente ao backup de cada data.
E pra ficar melhor ainda... ocupando menos espaço do que os backups originais, e tudo organizado e na mão, pronto pra uso.

No momento equivale a 553MB de backup, e ocupa 41MB.
Além das vantagens que já mostrei, ainda vou economizar espaço em disco.
E como mantenho 2 HDs de backup, mais de 1.5GB de economia, por enquanto, e mantendo a mesma informação.

Tutorial básico do GIT

MensagemEnviado: 20 Jun 2015 23:32
por JoséQuintas
Muita rotina de 2008 que dava até pra ser aproveitada por quem ainda usa Clipper.

- Atualização automática de EXE, com ajuda de VBScript
- Atualização automática de estruturas de DBF
- Consulta a webservice de CEP, com ajuda de VBScript
- DLLs em Clipper, com ajuda do Blinker
- Mouse em Clipper - muita gente ainda não sabe que dá pra fazer isso em Clipper
- PDF gerado totalmente por fonte Clipper
- Preview de impressão em Clipper, permitindo imprimir qualquer intervalo de páginas

Eu achava tudo isso normal na época, e achava que todo mundo fazia isso.
Em 2008 eu nem entendia o uso de codeblocks, e me achava atrasado no Clipper por isso....

Bons tempos... ganhava bem mais naquela época, e me divertia mais...

A propósito... em 2008 ainda usando compactação/descompactação, brigando com linhas de matricial/laser/jato de tinta, e PDF, se é que tinha, era com ajuda do VB.
E brigando pra descobrir como assinar uma nota fiscal eletrônica.

Tutorial básico do GIT

MensagemEnviado: 21 Jun 2015 00:00
por JoséQuintas
Cheguei em 2011.
Ainda em Clipper.
Mas mantendo os fontes compatíveis, preparados pra trocar.

#ifdef __HARBOUR__
   #include "sixcdx.ch"
    //ADO   #include "adordd.ch"
#else
   #ifdef _CL53_
      #include "ord.ch"
   #else
    #include "sixcdx.ch"
   #endif
#endif


Vixi... sou um bebê em Harbour então.
Estou no backup de 2011/04 e ainda não usava Harbour pra valer.

Tutorial básico do GIT

MensagemEnviado: 21 Jun 2015 00:15
por JoséQuintas
cheguei lá, aonde comecei o uso do Harbour pra valer.
Quase 4 anos atrás.
Uma das primeiras coisas foi usar mais espaço na tela.
O sistema estava preparado pra mudança, apesar de eu nunca ter usado diferente de 33x80 (ou seria 28x80)

* 04.08.11 - 2011.08.04 - Liberacao Harbour
* 11.08.11 - 2011.08.11 - Default para 35x100


Nota:
Meus comentários aqui são propositais.
Comentei no fórum sobre deixar fontes preparados pra Harbour, mesmo usando Clipper.
Comentei também de deixar fontes organizados e limpos, que facilita.
Comentei também sobre a fase do "vai, não vai" que é complicada.
Passei por isso.
Deixei como segundo plano, mas sem abandonar a idéia ao mexer nos fontes.
Até que um dia foi, e tava tudo preparado pra isso.....

Teve até fase de instalar Harbour no cliente num dia, e retirar no outro.... fazia parte... a atualização automática ajudou muito nisso.

Tutorial básico do GIT

MensagemEnviado: 23 Jun 2015 21:19
por JoséQuintas
Uma visão depois de concluído o processamento de backups: (só a parte esquerda da tela)

git.png


Por coincidência, um arquivo de linquedição para o Clipper/Blinker.

Tamanho atual das pastas controladas no git: 62.5MB
Tamanho da pasta .git, contendo esse histórico de 7 anos: 90MB

Achei uma opção interessante, quando se está exibindo todos os ramos.

git3.png


Dentre outras opções de filtragem, tem a de nome de arquivo.

git4.png
git4.png (11.62 KiB) Visualizado 2820 vezes


Dá pra selecionar pra ver o histórico completo de um único arquivo, ou pasta, ou conjunto.

Aí descobri algo interessante sobre renomear um arquivo:
Não podia ser diferente, ao renomear, o histórico de um acaba onde começa o outro.
Mesmo assim, só indicar os dois nomes nesse filtro, e vai continuar podendo ver o histórico completo.

Não sei se mostrei antes.
A única alteração no disco é esta, e só aparece se marcar pro Windows mostrar arquivos escondidos.
E por ele estar aí, significa que essas duas pastas estão sendo controladas.

git5.png
git5.png (10.29 KiB) Visualizado 2820 vezes


Pra copiar todos os backups, desde 1998, só copiar essa pasta GIT de 90MB.
Se todas as atualizações foram salvas, nem os arquivos atuais precisa salvar.

E copiando esse .GIT pra outra pasta, pode testar comandos nela, sem interferir na pasta de trabalho.
O git sempre considera a pasta atual como sendo a controlada. (atual + subpastas)

Tutorial básico do GIT

MensagemEnviado: 19 Set 2016 19:54
por JoséQuintas
Mais de um ano depois.
Filtrando só "commits" com alterações na classe Sefaz.

classesefaz.png


Lembrando:
isto é LOCAL, na máquina, mesmo que não seja usado um ambiente de backup na internet.
Basta o software GIT Windows.

De lá pra cá, passei a usar bitbucket.org como backup na internet.

Atualmente a pasta .GIT tem 172MB.
Simplificando: 172MB contém toda minha vida de programação, muito mais organizado do que se tivesse gravado separado.

Cabe também num mini DVD de 1.5GB, que cabe no bolso, com Harbour e tudo.

minidvd.jpg

Tutorial básico do GIT

MensagemEnviado: 02 Fev 2017 17:32
por rubens
JoséQuintas pelo que entendi, aqui você ensina a usá-lo local. Na Máquina...
E para a internet?
Teria como no final da tarde clicar num atalho e ele fazer o upload do que foi alterado, aí chegar em casa e fazer um download para o pc de casa do que foi alterado no pc de trabalho?
Pelo que pesquisei posso usar o github, só que para projeto privado tenho que pagar uma taxa mensal... e não é tão simples assim...
Porque conforme a dificuldade da coisa fica mais fácil e rápido um hd externo..

Me lembro que quando eu compilava o acbr bastava entrar na pasta clicar com o botão direito e escolher o comando update e baixava tudo que foi atualizado.
Na teoria é para ser um negócio simples, configurar pastas e arquivos, criar um botão upload. Pronto tá nas nuvens... onde eu chegar e rodasse o aplicativo(sei lá o quê) faria o download da atualização do projeto.. Simples... mamão com açúcar... kkk

obrigado
Rubens

Tutorial básico do GIT

MensagemEnviado: 02 Fev 2017 20:09
por JoséQuintas
Na verdade o uso é sempre local.
Pra internet só tem dois comandos a mais.
Acho que neste tutorial até mostrei essa parte.
Tem repositório grátis que dá pra usar particular.

Pra enviar pra internet, push
pra puxar da internet, pull

No geral faço o seguinte:
crio um vazio na internet.
Faco download disso, criando uma nova pasta com esse download.
A partir daí, só trabalhar na pasta, atualizar pelo git igual mostrado aqui, e push/pull

Caso já tenha um projeto pronto com git, vai ter que olhar lá como fazer.
Faz anos que fiz o meu, e não lembro mais.

Não precisa criar um pra cada projeto, pode colocar todos juntos.
Mas no cliente, vão acabar aparecendo todos, se fizer isso.

Aqui é a opção grátis, a dica foi passada aqui no fórum.

https://bitbucket.org/product

Só lembrando: git é o programa que controla tudo. GITHUB ou BITBUCKET são sites e tem repositório, e aceitam atualizar tudo pelo GIT.

Tutorial básico do GIT

MensagemEnviado: 23 Fev 2017 23:13
por JoséQuintas
Uia... descobri como criar o site a partir do repositório.
Só criar um repositório com o nome do site e pronto, o que estiver lá dentro vira o site.

https://josequintas.github.io/

Fica público.... então nada de senhas. O site está aqui:

https://github.com/JoseQuintas/JoseQuintas.github.io

Tutorial básico do GIT

MensagemEnviado: 08 Jul 2017 23:23
por JoséQuintas
Um passo a passo interessante, pra ver uma das vantagens.

Baixei o ZIP da hwgui, coloquei na pasta que tenho controlada pelo GIT (não confunda com GITHUB)
Teoricamente vou atualizar.

git1.png


Apago todos os fontes, e descompacto o arquivo ZIP "novo", e vejo as alterações.

git2.png


Vixe, não é mais novo, é mais velho.
E agora? apaguei tudo?

Simples:
Apago de novo, e digito um comando na pasta

git3.png


pronto, tudo de volta.

git4.png


Importante:
Caso tenha alterado alguma coisa, que não queira perder, é só salvar primeiro no git.
(se alterou o conteúdo de alguma pasta que faz parte do projeto)
Uma vez salvo, vai fazer parte do "retorno".

Muito prático isso, e tudo local.

Nota: apaguei novamente a pasta, pra poder postar vazia, por isso tem o comando duas vezes... e também errei na digitação, também erro de vez em quando, igual todo mundo.... rs

Tutorial básico do GIT

MensagemEnviado: 08 Jul 2017 23:32
por JoséQuintas
Ia me esquecendo.... esssa \allguipaulo é com os arquivos praticamente originais.
Tenho a \allgui que contém alterações minhas.

Então agora o trabalho é trazer as alterações da original para a alterada.

d:\CVSFiles\AllGui>git pull \cvsfiles\allguipaulo
remote: Counting objects: 1301, done.
remote: Compressing objects: 100% (1127/1127), done.
remote: Total 1301 (delta 486), reused 541 (delta 88)
Receiving objects: 100% (1301/1301), 1.09 MiB | 0 bytes/s, done.
Resolving deltas: 100% (486/486), completed with 404 local objects.
From \cvsfiles\allguipaulo
* branch HEAD -> FETCH_HEAD
Auto-merging hmge/SOURCE/h_windows.prg
CONFLICT (content): Merge conflict in hmge/SOURCE/h_windows.prg
Auto-merging hmge/SOURCE/h_init.prg
Auto-merging hmge/SOURCE/h_error.prg
Auto-merging hmge/SOURCE/c_winxp.c
Auto-merging hmge/SOURCE/c_winapimisc.c
Auto-merging hmge/SOURCE/c_tooltip.c
Auto-merging hmge/SOURCE/c_tab.c
Auto-merging hmge/SOURCE/c_draw.c
Auto-merging hmge/SOURCE/c_controlmisc.c
Auto-merging hmge/SOURCE/HbPrinter/winprint.prg
Auto-merging hmge/SAMPLES/Advanced/Tsb_addrecord_3/demo.prg
CONFLICT (content): Merge conflict in hmge/SAMPLES/Advanced/Tsb_addrecord_3/demo.prg
Removing hmge/SAMPLES/Advanced/PdfView/PdfView_Sumatra.prg
Auto-merging hmge/Include/minigui.ch
Auto-merging hmge/Include/i_window.ch
CONFLICT (content): Merge conflict in hmge/Include/i_window.ch
Auto-merging hmge/Include/i_controlmisc.ch
Automatic merge failed; fix conflicts and then commit the result.


quase deu certo de forma automática, tem alguns arquivos que vão precisar de ajuste manual.
De qualquer jeito, mais fácil conferir somente esses fontes indicados, do que todos um a um.
Agora vai depender da alteração, pode ser que um copy desses arquivos seja suficiente.
Todas as demais alterações "se encaixaram".

Tutorial básico do GIT

MensagemEnviado: 08 Jul 2017 23:42
por JoséQuintas
essa é uma parte que não peguei o jeito ainda, então vai do jeito antigo:

d:\CVSFiles\AllGui\hmge\Include>fc i_Controlmisc.ch \cvsfiles\allguipaulo\hmge\include\i_controlmisc.ch
Comparando os arquivos i_controlmisc.ch e \CVSFILES\ALLGUIPAULO\HMGE\INCLUDE\I_CONTROLMISC.CH
***** i_controlmisc.ch
#translate CRLF => hb_Eol()
***** \CVSFILES\ALLGUIPAULO\HMGE\INCLUDE\I_CONTROLMISC.CH
#translate CRLF => hb_OsNewLine()
#ifndef __XHARBOUR__
#define hb_OsNewLine() hb_eol()
#endif

*****


Provavelmente ajustaram os espaços em branco nessa declaração pra xHarbour, que nem existe no meu alterado.
O conflito foi justamente não poder mexer nos espaços em branco da linha, porque a linha não existe mais.
Se a linha existisse, teria integrado automático.

Tutorial básico do GIT

MensagemEnviado: 08 Jul 2017 23:51
por JoséQuintas
Também dá pra ver pelo próprio git.
É que ainda não me acostumei com isso.

Resolvendo os conflitos, é só salvar e pronto.

Nada mal, uma HMGE extended modificada ser atualizada em minutos.

É assim que os "Harbours" podem se atualizar entre si, tanto 3.2 pra 3.4 ou 3.4 pra 3.2.

Tutorial básico do GIT

MensagemEnviado: 09 Jul 2017 00:01
por JoséQuintas
Só pra completar essa parte:

Veja que para o GIT não importa se está usando pastas, servidor ou internet, ele trabalha do mesmo jeito.

git clone https://github.com/vszakats/harbour-core harbour34


Isso cria a pasta harbour34 contendo.... o Harbour 3.4 óbvio.

De repente, uma alteração urgente no Harbour 3.2.... vamos coloca-la no "nosso" Harbour 3.4

git pull https://github.com/harbour/core


Pronto, feito.
Fizemos antes do Viktor.

Talvez dê pra usar isso no OneDrive, no googledrive, e teremos um repositório grátis nas nuvens.
Vale pra fontes, DBFs, EXEs, qualquer backup que queira controlar pelo GIT.
Até mesmo backup do MySQL.

Não sou expert, só conheço o básico do GIT, mas esse básico já me permite fazer muita coisa.
Como eu sempre digo: aprenda bem o básico, o resto vém com o tempo ou com a necessidade.
De um jeito ou de outro, o básico resolve.
Mas básico ruim.... aí ferrou....

Por exemplo: se a parte acima deu pane.. tudo bem o básico: restaura as pastas, tá tudo no GitHub pode apagar tudo e começar de novo.

Seus fontes particulares.... idem.

Tutorial básico do GIT

MensagemEnviado: 05 Set 2018 09:28
por JoséQuintas
Hoje uso mais que isso, se não me engano 40 x 132.

A largura de 132 é pra acomodar um relatório compactado, que caberia nas folhas de 80 colunas., pra caber o relatório inteiro na tela.
A altura de 40 foi pra acomodar telas que precisavam de mais espaço.

Nos tempos do Clipper eu usava as disponíveis para o DOS/Console que eram 25 x 80 ou 28 x 80

Num cliente novo, aplicativo próprio, acostumado com 25 x 80, fui aumentando aos poucos, acho que é aonde ainda usa 35 x 100.

Talvez nesse atual do Flagship, ao usar Harbour, comece aumentando aos poucos, pro pessoal se acostumar.

Pra quem não está acostumado, usar letra menor acaba estranhando, e sempre quer voltar pra maior.
Acredito que tenha acontecido com todo mundo aqui no fórum que usa console, quando entraram as máquinas 1024 x 768.
A gente achava a letra muito pequena, e alterava a resolução, até acostumar de vez.

Tutorial básico do GIT

MensagemEnviado: 05 Set 2018 13:27
por JoséQuintas
Que eu me lembre, comentou de usar console.

Minha rotina de mensagem é nas duas linhas inferiores, uso MaxRow() - 1 e MaxRow()
Meu Browse, é até MaxRow(), MaxCol().
Tenho um Cls(), que limpa a tela até MaxRow() - 3.

Desse modo, tanto faz o que for escolhido, as rotinas principais já acompanham o tamanho de tela.
O resto vai conforme a necessidade.

Voce poderia seguir o mesmo esquema:
Com o tempo vai usando mais linhas, se precisar.
Para o cliente, vai ser algo como versão nova, ou pra ir se acostumando.
Pelo menos não vai precisar refazer todos os fontes...

Tutorial básico do GIT

MensagemEnviado: 05 Set 2018 13:46
por rossine
Olá,

Existe uma versão do GitGui ou alguma configuração para Português-BR ?

Obrigado,

Tutorial básico do GIT

MensagemEnviado: 05 Set 2018 13:55
por JoséQuintas
Não lembro como fiz isso, mas

Se olhar os primeiros posts deste tópico, as telas estão em português.

Tutorial básico do GIT

MensagemEnviado: 05 Set 2018 17:09
por rossine
Olá José,

Baixei o GitGui do link que você citou, https://git-scm.com/ mas vem em inglês.

Tutorial básico do GIT

MensagemEnviado: 25 Jun 2019 09:24
por JoséQuintas
Achei este link hoje:

https://woliveiras.com.br/posts/comandos-mais-utilizados-no-git/

em PDF:
git-comandos.pdf
(708.07 KiB) Baixado 49 vezes

Tutorial básico do GIT

MensagemEnviado: 10 Jun 2020 14:55
por JoséQuintas
Hoje precisei pesquisar uma informação nos "backups" do git, não encontrei, mas achei interessante o recurso.

fontegit.png


- Filtrei pelo nome do fonte que me interessava - no view/edit view
- Filtrei a palavra PDF nos commits - no view/edit view

E por último, coloquei ali PDF pra aparecer em destaque.

O fonte é gigantesco, então quanto mais ajuda melhor.
Sumiu a informação sobre a transação na impressão do pedido.
Estava tentando encontrar quando foi a última vez que ela existiu.
Não encontrei, mas as opções são interessantes.

Nota: dá pra perceber que eu alterei :String(), :Number() e :Date(), pra :ToString(), :ToNumber(), :ToDate().
Mas começou a gerar problemas, por estar acostumado assim, então voltei ao que estava antes.
Só comentário.

Tutorial básico do GIT

MensagemEnviado: 16 Dez 2020 13:33
por JoséQuintas
Andei descobrindo umas coisas novas do GIT.

Não resolve tudo, mas ajuda: BRANCHES.

De forma resumida: você cria pontos a partir de determinada situação do fonte, e trabalha com versões diferentes.

Exemplos:

De repente você trabalha na versão anterior, atual e seguinte do software.
Pode alterar o que vale pra todas de uma vez, ou o que vale só pra uma ou outra.

Acho que a integração do Harbour 3.2 on 3.4 é parecida com isso.
Cria a versão paralela contendo atualizações, e vai conferindo uma por uma.

Vi o comando GIT PICK, ou parecido, mas que no GIT GUI tá mais fácil fazer por visual, onde você escolhe uma alteração que já foi feita numa "versão", e integrar com a outra, de forma totalmente automática.
Continua trabalhoso, mas pelo menos seria uma forma de conferir CADA mudança do 3.2 pra ser incorporada no 3.4.
Melhor trabalhar com uma alteração pequena por vez, do que tudo de uma vez.

Tutorial básico do GIT

MensagemEnviado: 16 Dez 2020 13:38
por JoséQuintas
olhem como ajuda, visualmente dá pra ver o que falta integrar.
Nesse caso são diferenças do meu fork, mas com branches é parecido.

difhb.png

Tutorial básico do GIT

MensagemEnviado: 16 Dez 2020 13:43
por JoséQuintas
Seria essa opção cherry-pick
Ela incorpora a alteração selecionada de uma versão pra outra.
Mais uns 10 anos e começo a entender mais coisas kkkk

Isso também pode me ajudar na atualização das LIBs que já reclamei aqui de perder alterações.
Basta eu criar um desses "desvios" (branches), e atualizar diretamente a original velha com a original nova, e minhas alterações serão aplicadas na nova versão !!!!
Inclusive... confirmar se as alterações que envio já estão valendo ou não... fica muito mais tranquilo. não tem limites.

git.png

Tutorial básico do GIT

MensagemEnviado: 16 Dez 2020 13:59
por JoséQuintas
Pena que hwgui não está no github, mas ..... até coloquei 2.17 e 2.20 pra brincar....

hwgui.png
hwgui.png (6.23 KiB) Visualizado 455 vezes


Assim fica mais interessante conferir o que mudou de uma pra outra, podendo dividir essa alteração total em alterações parciais e menores.

Lembrando que isso está disponível pra NOSSOS FONTES, não apenas fontes de LIB ou do Harbour.

Tutorial básico do GIT

MensagemEnviado: 17 Dez 2020 10:28
por JoséQuintas
O recurso tem.... mas ainda não entendi como usá-lo.

hwgui.png


na posição: hwgui update é o conteúdo atual da hwgui, já salvo
na posição: revert... é a original sem as últimas atualizações
gtwvg and hbwin.ch é a que eu tinha antes, com alterações que a atual não tem e outras que já tem

Na visualização embaixo, é a diferença entre a hwgui atual, e o que eu já mexi aqui, apenas um commit.

o objetivo seria criar um novo commit, contendo apenas o que resta a ser alterado no oficial.
Já vi que o ideal seria fazer pequenos commits, um "pequeno assunto" de cada vez, assim daria pra acertar tudo no automático, apenas movendo a ordem das alterações.
E usando branch, assim o branch seria uma espécie de lista pendente.

Aliás... tem essa também...
dá pra ficar juntando muito lixo no repositório... por exemplo, alterações de teste que nunca serão usadas oficialmente....
mas melhor lá do que no ambiente de trabalho kkkk
de certa forma, testes paralelos também fazem parte da história.... mesmo se não forem usados depois, então faz sentido.

Por exemplo, no meu caso, que não converti a contabilidade ainda, e aguardando outras coisas.... poderia já ir convertendo mesmo sem instalar em nenhum cliente.
Tudo controlado, mesmo sem uso, o difícil vai ser acostumar pra não fazer besteira, mas é muito interessante.
Sua máquina sempre limpa, somente com o que estiver mexendo naquele momento....

E se fizer besteira.... atualizar versão errada, por exemplo.... é só usar o cherry pick, desfazer da versão errada, e fazer na versão certa, automático.

Se salvar no github na fase intermediária, a fase intermediária também vai pra lá.
se deixar esse "lixo" só na máquina local (fica escondido), pode apagar o lixo depois.
Com lixo e tudo, é menos espaço do que se fosse ficar fazendo backup.

Equivale a ter backup de tudo, poder comparar tudo, poder transferir alteração, tudo de forma organizada e automática/semi-automática.
Tudo anotado... muito doido isso, mas muito bom.

Mas voltando ao assunto: não sei exatamente o que fazer agora, a sorte é que tem poucas alterações, e dá pra fazer de novo, de forma separada.
E tá tudo sob controle no git, posso até deixar pra ele mesmo conferir.

Tutorial básico do GIT

MensagemEnviado: 17 Dez 2020 15:49
por JoséQuintas
Aproveitando.... pra mostrar outra utilidade dos branches:

A GTWVG que vocês conheciam..... é do Harbour 1.0... de 2008, 12 anos atrás.

https://github.com/vszakats/hb/tree/v1.0.0dev/harbour/contrib/gtwvg

No Harbour 2.0 que a nova GTWVG com API Windows apareceu.

https://github.com/vszakats/hb/tree/v2.0.0dev/harbour/contrib/gtwvg

No Harbour 3.0 foi onde recebeu uma repaginada

https://github.com/vszakats/hb/tree/v3.0.0dev/harbour/contrib/gtwvg

De lá pra cá, poucas mudanças.

Tutorial básico do GIT

MensagemEnviado: 17 Dez 2020 18:06
por JoséQuintas
A propósito....

A GTWVG do Harbour 2.0 está mais amigável, pra quem quiser estudar API do Windows, ou até criar biblioteca própria, ou mexer na HWGUI.
As classes não usam herança, e por isso ficam mais amigáveis pra quem não está acostumado.
Tem até texto copiado da Microsoft nos fontes, como documentação.

https://github.com/vszakats/hb/blob/v2.0.0dev/harbour/contrib/gtwvg/wvgpushb.prg

Tutorial básico do GIT

MensagemEnviado: 17 Dez 2020 20:34
por JoséQuintas
rossine escreveu:Olá José,
Baixei o GitGui do link que você citou, https://git-scm.com/ mas vem em inglês.


Desculpe, não vi sua mensagem antes.
Não sei se tem em português, mas acho que traduzir só vai complicar.

Tutorial básico do GIT

MensagemEnviado: 17 Dez 2020 20:48
por JoséQuintas
O que mostrei, e vou mostrar de novo, fica aqui

git1.png


Após selecionar isso, aparece esta outra tela, que é totalmente independente da primeira mas......
MUITA ATENÇÃO E MUITA CALMA NESSA HORA

git2.png


Imagine voce trabalhando na versão atual, precisar mexer na anterior, depois voltar na atual, desfazer alterações, etc. etc.
Já imaginou como faz hoje?

Por esse menu que apareceu, você faz tudo isso.
Mas muito cuidado pra não fazer uma zona com tudo.

Por exemplo.... no meu git....
Posso selecionar aí pra voltar pra versão Clipper de 12 anos atrás, e já sair compilando a versão Clipper. (não uso mais)
Depois selecionar pra versão em DBF, e já sair compilando. (não uso mais)
Depois selecionar pra versão em MySQL, e já sair compilando.
E posso fazer uma atualização que vai afetar todas as versões de uma vez.

Tudo isso em poucos cliques, talvez 3, tudo na mesma pasta, tudo sempre pronto.
Tipo... tudo isso sempre na pasta \aplicativo
Mudou aí, vai lá na pasta aplicativo e tá tudo diferente, de 10 anos atrás.
Mudou de novo, tá lá na pasta tudo do jeito atual.

Pois é... tantos anos usando e só agora que descobri esse básico.

Mas MUITO CUIDADO. Apesar do git avisar sobre salvar o que ainda não foi salvo.... pra não perder alterações em andamento.... é bom não arriscar.
Pode salvar trabalho incompleto e continuar depois, ou desfazer, sem problemas, então a primeira coisa é aprender/lembrar de sempre deixar salvo.

É muito doido isso, seria equivalente a ficar trocando de computador num clique, ou ter várias máquinas virtuais, etc.
Ao invés de complicações, bastam 3 cliques....

Tutorial básico do GIT

MensagemEnviado: 17 Dez 2020 20:54
por JoséQuintas
A propósito....
Tava vendo uma explicação sobre as diferenças entre GIT e SVN.
Uma diferença é que SVN salva sempre uma cópia do arquivo completa, e o GIT não.
Se pensar em arquivos de 10MB, o SVN poderia usar 10MB a cada alteração, enquanto o GIT ocuparia alguns bytes.
Com certeza deve ter otimização interna, senão...... haja espaço.

Por isso acaba existindo opção grátis.
O histórico do Harbour COMPLETO, desde a versão 0, ocupa 350MB.

O meu tá ocupando 570MB... mas também salvo ícones, documentos, etc. , fora LIBs, EXEs, e backups, que salvei errado durante esse tempo todo.
Tá tudo lá, algum dia vou fazer limpeza disso. Já tem anos de histórico em uso direto, mas tem 12 anos de história parcial, porque salvei backups antigos também.
Tem até fonte de aplicativo que desativei há mais de 10 anos... e tudo num único projeto.

Tutorial básico do GIT

MensagemEnviado: 19 Dez 2020 17:21
por JoséQuintas
Ainda pegando o jeito....

Aí é na minha máquina local.
Criei um branch JoseQuintas, com minhas alterações particulares.

git3.png


E isso pode ser salvo também no github, e pode ser selecionado o que visualizar.

git1.png


git2.png


Dá pra ter várias versões ao mesmo tempo, e todas disponíveis pra download.
E dá pra definir qual é a default.

Na máquina local, dá pra ficar trocando de uma pra outra.

Há várias visões:

- o que está na máquina (que podemos trocar versão)
- o que está salvo no github
- a posição final de trabalho
- e branches intermediários com a mesma coisa
- Salvar branches é opcional, podem ficar somente local, tipo... pra reorganizar tudo antes de salvar

Notem que mesmo diferente, continua sincronizado com o original.
E pra cada branch mostra uma comparação diferente.
Posso puxar atualizações pra qualquer um deles, ou pros dois, etc.
É só ir gerenciando.

Só não sei se isso vai aparecer no master, ou se fica só no meu fork.

Tutorial básico do GIT

MensagemEnviado: 19 Dez 2020 17:44
por JoséQuintas
Lembrando:

O GIT é um software, que usamos LOCAL.
Criar backup nas nuvens, usando GITHUB ou BITBUCKET é OPCIONAL.

Tudo isso está disponível para NOSSOS FONTES particulares.
Venho usando git, github e bitbucket faz tempo, mas esta parte que mostrei agora é novidade pra mim.

Pois é... sabendo um pouquinho já ajuda... e com o tempo vai aprendendo mais coisas.
Perder fontes é ruim pra todo mundo, então é uma ferramenta de extrema utilidade.

Tutorial básico do GIT

MensagemEnviado: 27 Dez 2020 12:51
por JoséQuintas
Mais um recurso interessante, pensava que já usava, mas não usava direito.

Tenho lá os projetos:

hmg
hmge
hwgui
oohg core
oohg samples
oohg distros
oohg doc
oohg shared
oohg fmt

agora criei um novo, sem nada, só com o gitflow.

em minha máquina
git submodule add hmg
git submodule add hmge
etc.

se tudo der certo, a partir do all gerencia todos, e vai dar pra acertar um gitflow pra compilar tudo de uma vez.
pra hmg criei um independente do original, porque o original tem harbour e mingw, mais de uma versão, e isso deixa o conteúdo pra baixar muito grande.

ao mesmo tempo, eles são independentes, e são juntos, depende de por onde baixar.
Para oohg, que são forks, posso continuar contribuindo com o original.

https://github.com/JoseQuintas/testall

Tutorial básico do GIT

MensagemEnviado: 27 Dez 2020 14:33
por JoséQuintas
test.png


Estou comprovando tudo que venho falando faz tempo.
Esse testall contém tudo, mas.....
Pra cada projeto vinculado, está se referindo a uma posição exata do projeto.

Agora imaginem isso aplicado pra tudo.
Cada um poderia baixar o Harbour que interessa, as LIBs que interessam, tudo do mesmo lugar, mesmo que cada um baixe versão diferente.

O github faz todo trabalho.
Basta vincular máquina, sistema operacional, pacotes, comandos, etc. e ele já compila/linquedita/zipa e deixa pronto pra download.

E tanto faz se for Harbour ou XHarbour.

Agora só falta fazer a parte de compilar/linqueditar..... por isso juntei tudo num só, pra não precisar configurar cada um.

Só pra lembrar:
Como isso também funciona pra nossos aplicativos.....
Não precisaríamos nem mesmo computador pra compilar/linqueditar....
Só criar a conta particular que é grátis, e pronto, fica pra uso exclusivo.

Tutorial básico do GIT

MensagemEnviado: 27 Dez 2020 15:40
por JoséQuintas
Convém deixar anotado:

git submodule add ../hmge hmge

é o path relativo ao "meu" projeto atual, e a pasta relativa de destino.

pra remover;

git submodule deinit hmge

caso não baixe usando o recurso de --recurse (recursivo)

git submodule init hmge

e tem outro interessante --depth 5
Baixa somente o histórico dos últimos 5 commits.

Pra baixar tudo de uma vez, com subprojetos, somente histórico com últimos 5 commits:

git clone endereco --recurse --depth 5

E pra trabalhar/atualizar, continua o de sempre, nada muda.
o projeto geral tá sempre apenas com indicação dos outros, e cada projeto com sua história separada.

Nota: vale para o Harbour também, assim baixa mais rápido. Se não precisar a vida toda desde o Harbour 0.0.... assim é melhor.

Tutorial básico do GIT

MensagemEnviado: 27 Dez 2020 19:16
por JoséQuintas
Acrescentei o Harbour 3.4.

Importante:

o testall NÃO TEM NADA, apenas links para os outros projetos.
Só que se baixar recursivo, baixa todos os projetos de uma vez, organizados em pastas.

Tutorial básico do GIT

MensagemEnviado: 27 Dez 2020 19:21
por JoséQuintas
d:\github\all>git status

On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
  (commit or discard the untracked or modified content in submodules)
        modified:   oohg (modified content)

no changes added to commit (use "git add" and/or "git commit -a")


Apenas está informando que está tudo ok no projeto, mas.... o subprojeto oohg contém alterações.

Tutorial básico do GIT

MensagemEnviado: 27 Dez 2020 22:03
por JoséQuintas
hwgui1227.png


Ficou meio esquisito, mas deu certo, foi a primeira vez.
Acabou virando 3 versões que se encerraram iguais.

Apesar de tudo, não preciso desse controle detalhado, então talvez faça isso sem salvar a "história do acerto".

linha do tempo 1: anterior + minhas alterações + diferença
linha do tempo 2: anterior + hwgui nova + minhas alterações
linha do tempo 3: anterior atualizada + diferença

Ao contrário do que pensávamos (pelo menos eu), isso não mostra o quanto está diferente, isso apenas mostra quais os "commits"/alterações foram aplicados.

Tutorial básico do GIT

MensagemEnviado: 30 Dez 2020 15:48
por JoséQuintas
Mais outro, mas cuidado.
É pra reescrever todo histórico.

git rebase -i HEAD~15

Com esse comando, vai aparecer um arquivo txt pra ser editado, com a lista dos últimos 15 commits.
Todos tem a palavra "pick" que significa manter.
Pode ser alterada para:

drop - excluir
squash - juntar com o anterior
edit - editar
e outras

se limpar tudo, não faz nada.
Se alterar as palavras, é o que vai ser feito.

git.png


Por default, é criada uma linha do tempo paralela, que pode ser salva no github, ou com outros comandos, pode assumir o papel principal.
Ainda não me acertei nisso de substituir o histórico, mas pelo menos o resultado foi o que eu queria.

Eliminei todas as alterações que tinha feito pra teste na WVG, foi isso que eu fiz, para o histórico ficar só com a parte "útil".
Só não acertei na hora de salvar no github, então, ficou com as duas linhas do tempo.

Pensando bem.... acertei, porque não apareceram as inclusões/exclusões.
Agora ficou confuso porque mostra duas linhas do tempo, ou a forma em que aparecem.
Excluí 4 alterações, não ficou visível isso, dá a impressão de que excluí 6.

Tutorial básico do GIT

MensagemEnviado: 03 Jan 2021 01:04
por JoséQuintas
Estou fazendo o teste agora por curiosidade.

Existe sempre uma origem e a cópia de trabalho.
Se a origem é GITHUB ou SEU SERVIDOR, ou a própria máquina, tanto faz.

No meu servidor:

git clone enderecogithub all

Isso cria uma cópia do github para meu servidor
Meu servidor vai atualizar o github, que é a origem

git clone enderecoMEUservidor all

isso cria uma cópia do meu servidor para minha máquina
Minha máquina vai atualizar MEU SERVIDOR, que é a origem

git clone pastaoriginal pastabackup

Isto vai criar uma cópia da pasta original pra backup.
a pasta backup vai atualizar a pasta original.
No final, o que chamei de backup acabaria sendo a cópia de trabalho.

É só curiosidade, isso poderia só complicar, porque teria que rodar atualização em todos, pra chegar no github.

Mas por outro lado, mostra como criar um servidor próprio, que poderia até atualizar por uma VPN.

NÃO existe software especial no servidor, apenas existe a pasta compartilhada.
Se quiser, pode instalar o git no servidor, pra comunicação entre servidor/github quando precisar, SE usar o github.

Não é complicado entender.

Você tem um lugar que é o salvamento de tudo, é o principal, pode ser com opção de mexer ou não.
Pode ser no github.
Aí pode fazer uma cópia para o seu servidor, seu servidor vai atualizar o github.

Na sua máquina, pode fazer uma cópia do github ou do seu servidor.
Se fizer uma cópia do github..... vai atualizar o github
Se fizer uma cópia do seu servidor... vai atualizar o seu servidor
Aqui, quando digo cópia, é usando git clone ....

O git não precisa do github, você pode criar o controle do zero, no seu servidor ou na sua máquina.
Criando no seu servidor, seu servidor seria seu github particular.

Já como eu mencionei no começo, cópia da cópia da cópia.....
o github é o servidor do seu servidor
seu servidor é o servidor da sua máquina
sua máquina seria o servidor da sua outra pasta

Nesse jeito exagerado, uma pasta sua atualizaria a outra.
A outra atualizaria seu servidor
e seu servidor atualizaria o github
Mas como é tudo manual e não automático, correria o risco de esquecer de algum deles.
Foi só exemplo, pra mostrar com possibilidades expandidas.

Tutorial básico do GIT

MensagemEnviado: 13 Jan 2021 20:34
por JoséQuintas
git.png


Comentei sobre o recurso de reescrever o histórico.
Está aí uma boa utilidade pra ele.
Não vou querer esse monte de testes no histórico.

Tutorial básico do GIT

MensagemEnviado: 13 Jan 2021 20:43
por JoséQuintas
git rebase -i HEAD~50

rebase1.png


me abriu a lista pra dizer o que fazer.
pick=mantem
squash=agrupa
drop=apaga

rebase2.png


pedi pra agrupar, e aí fecho o editor de textos e ele trabalha

rebase3.png


agora me pediu pra escolher o nome do commit, vém tudo, deixo só o que vai ficar.

rebase4.png


fechou o editor de textos, pronto.
Até parece que consegui logo de primeira.... rs
Mas é porque com tudo aquilo de histórico, fica uma zona pra encontrar alguma coisa, melhor assim.

confere isso com muita atenção, porque depois não vai ter volta....
o passo final é git push -f
o -f é pra FORÇAR a atualização, senão o github nem deixa salvar, porque não bate com o que ele tem.

Tutorial básico do GIT

MensagemEnviado: 07 Fev 2021 14:39
por JoséQuintas
Deixar anotado aqui.
CUIDADO com esses comandos.

É pra reescrever todo histórico, fazendo modificações.

git filter-branch --tree-filter "rm -rf FONTES" --prune-empty

O comando acima é pra remover a pasta FONTES de todo histórico.
Ainda em andamento, vai mais uns 20 minutos até terminar, pra ver se deu certo.

git filter-branch --force --tree-filter "mv FONTES/INTEGRA integra || true"

O comando acima é pra mover a pasta FONTES/INTEGRA pra integra.
O true a mais é para os casos aonde der erro, pra considerar que deu certo mesmo assim.
É que se mover mas não existir dá erro e aborta tudo, com o true continua mesmo se não existir.
Mesmo caso, ainda em andamento, talvez mais 20 minutos pra terminar, pra ver se deu certo.

--tree-filter
--index-filter

Vi que tem essas duas opções, que são interessantes, dependendo do caso.
--index-filter faz pelos "commits", pelo histórico, acaba usando pasta temporária
--tree-filter faz na pasta oficial.

No caso de conflito, aparece lá pra resolver, e fica tudo com o conteúdo "da época".

Conflitos, depende do caso, pra ser fácil resolver ou não.

Tem o rebase que já mencionei antes também, que também pode ter conflitos.

Vamos a alguns casos:

- No manual: você remove uma pasta ou um fonte.
Todas as próximas atualizações que mexeram com essa pasta/esse fonte, vão acusar conflito, porque elas não vão poder mexer no que foi apagado.
Nesse caso é só acrescentar que continua excluído desse commit.
Cuidado ao fazer isso com 3.500 atualizações, porque teria que corrigir um por um, até terminar, caso seja uma pasta muito atualizada.
Para esses casos, o filter-branch será uma melhor opção, porque faria automático com todos.

- sub-projetos
Temporariamente estou removendo isso.
O lado bom é ficar vinculado ao ponto exato do sub-projeto.
O lado ruim, é que ao reescrever histórico, esses pontos não podem ser alterados, o que causa aqueles desvios como uma versão paralela.
Continua tudo bem controlado, mas .... pode causar muita confusão ao olhar histórico.
Isso também acontece com forks... é uma coisa comum, e por isso não pode perder o controle, e precisam existir as "versões paralelas".

A prioridade no git/github é não perder fontes.
As versões paralelas são justamente pra não perder nada, até mesmo se alterar todo histórico e todas as alterações.
É bom lembrar disso, porque às vezes vai parecer que seu histórico está ficando doido, mas é porque na prática é você quem dá a palavra final sobre como manter o histórico após uma alteração: pode manter o controle paralelo ou pode sumir com ele de vez.

Não sei como funciona a cobrança do github num caso desses, pra conta particular, mas parece que o tamanho do controle não importa.
Parece que a cobrança é sobre resultados, e não sobre o projeto, por exemplo gerar e guardar pacotes prontos do projeto (o aplicativo gerado, por exemplo).

Mas fica aí, sobre o que pesquisar: filter-branch
pra quando quiser mudar toda a sua história de fontes/alterações.

Tutorial básico do GIT

MensagemEnviado: 07 Fev 2021 16:42
por microvolution
JoséQuintas escreveu:CUIDADO com esses comandos.
nem me atrevo... coisa só pra nerds rsrsrrs