Monitorando mudanças de diretório com Git para construir o Lume

Olá, sou um inútil.
Há um tempo atrás,
Reconstruir apenas quando houver uma mudança no LumeCMS, um site estático SSG, usando inotifywait
Eu configurei isso para construir automaticamente, mas percebi que não era muito estável: ele era acionado quando arquivos de troca do vim eram criados, os processos morriam sem aviso, e as construções eram executadas desnecessariamente. Então pensei: 'Se eu gerenciar com git, posso acionar o fluxo de construção quando houver mudanças, e posso reverter se algo der errado, o que seria bom, certo?' E como algumas ideias para scripts de shell já estavam surgindo na minha cabeça, decidi tentar.

É assim

O código completo desde o início
Também está disponível no Github.

#!/bin/bash

LUME_DIR="/your/lume/dir"
SRC_DIR="$LUME_DIR/src"
BUILD_DIR="site"
WEBPSH="/your/webp/convert/path"
COMMIT_COMMENT="`echo "Memory" && free -h | head -2 | awk  '{print $(NF-5)"," $(NF-4)"," $(NF-3)}' | column -t -s ","`"

export DENO_INSTALL="/home/$USER/.deno"
export PATH="$DENO_INSTALL/bin:$PATH"

cd "$SRC_DIR" || exit
ls "$SRC_DIR/.git" || git init || exit
git add . || exit

git commit -m "$COMMIT_COMMENT"

if [ $? -eq 0 ]; then
  $WEBPSH
  cd $LUME_DIR || exit
  # deno task lume --dest=$BUILD_DIR
  deno task lume --dest=$BUILD_DIR > /dev/null 2>&1
else
  exit 1
fi

De qualquer forma, eu queria implementar com o código mais curto possível, então ficou assim.
Bem, o COMMIT_COMMENT está um pouco bagunçado, mas é por diversão...

No início, eu estava registrando o tempo com date, mas agora percebi que posso verificar com git log, então não é mais necessário, certo?
(Talvez eu possa até colocar alguma arte ASCII aleatória agora...)

O script acima da imagem é executado a cada 5 minutos via cron.

Vamos ver o valor de retorno do git

De qualquer forma, o valor de retorno de git add . no git não parece ser capaz de detectar mudanças. Por exemplo, o valor de retorno quando git init não foi executado:

alleycat:[haturatu]:~/git/gittest$ ls -la
合計 8
drwxr-xr-x  2 haturatu haturatu 4096 10月 14 01:08 .
drwxr-xr-x 72 haturatu haturatu 4096 10月 14 01:08 ..
alleycat:[haturatu]:~/git/gittest$ git add .
fatal: not a git repository (or any of the parent directories): .git
alleycat:[haturatu]:~/git/gittest$ echo $?
128

É 128.
Agora, vamos criar ou excluir um arquivo depois de executar git init.

alleycat:[haturatu]:~/git/gittest$ ls -la
合計 12
drwxr-xr-x  3 haturatu haturatu 4096 10月 14 01:11 .
drwxr-xr-x 72 haturatu haturatu 4096 10月 14 01:08 ..
drwxr-xr-x  7 haturatu haturatu 4096 10月 14 01:11 .git
alleycat:[haturatu]:~/git/gittest$ git add .
alleycat:[haturatu]:~/git/gittest$ echo $?
0
alleycat:[haturatu]:~/git/gittest$ touch test
alleycat:[haturatu]:~/git/gittest$ ls -la
合計 12
drwxr-xr-x  3 haturatu haturatu 4096 10月 14 01:11 .
drwxr-xr-x 72 haturatu haturatu 4096 10月 14 01:08 ..
drwxr-xr-x  7 haturatu haturatu 4096 10月 14 01:11 .git
-rw-r--r--  1 haturatu haturatu    0 10月 14 01:11 test
alleycat:[haturatu]:~/git/gittest$ git add .
alleycat:[haturatu]:~/git/gittest$ echo $?
0

Portanto, o valor de retorno de git add . não muda, então não é possível detectar mudanças.
Então, vamos ver o valor de retorno quando você faz um commit.

alleycat:[haturatu]:~/git/gittest$ ls -la
合計 12
drwxr-xr-x  3 haturatu haturatu 4096 10月 14 01:11 .
drwxr-xr-x 72 haturatu haturatu 4096 10月 14 01:08 ..
drwxr-xr-x  7 haturatu haturatu 4096 10月 14 01:11 .git
-rw-r--r--  1 haturatu haturatu    0 10月 14 01:11 test
alleycat:[haturatu]:~/git/gittest$ git commit -m "nyaa"
[master (root-commit) 60bed93] nyaa
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 test
alleycat:[haturatu]:~/git/gittest$ echo $?
0
alleycat:[haturatu]:~/git/gittest$ git commit -m "nyan nyan"
On branch master
nothing to commit, working tree clean
alleycat:[haturatu]:~/git/gittest$ echo $?
1

Parece que 1 é retornado se não houver mudanças.
Portanto, podemos determinar a partir deste valor de retorno, e o resto é fácil.

Monitoramento de mudanças que parece bastante profundo

Então, sinto que este método de gerenciamento de mudanças pode ser útil para outras coisas também.
No entanto, o que eu sempre procuro é uma maneira mais fácil, leve e recursiva de monitorar mudanças de diretório, o que parece simples, mas não é.
No caso do comando find, é um comando muito poderoso, então executá-lo para monitorar mudanças é um pouco incômodo (será que ele também é executado como um comando interno do git?).
Se você tiver que escrever seu próprio código de monitoramento de mudanças, também precisará incluir verificações para diretórios a serem excluídos. Nesse sentido, o monitoramento de mudanças feito com git é superior, pois você pode simplesmente listar os diretórios desnecessários que não deseja monitorar em .gitignore, efetivamente excluindo-os do monitoramento de mudanças.

Nesse ponto, o git é excelente.
No entanto, no caso do git, ele armazena o cache em .git, então pode não ser adequado para monitorar diretórios com arquivos grandes. Portanto, você poderia fazer o hash de cada arquivo, armazená-los como arquivos de texto em /tmp, e se o diff retornar um valor indicando uma diferença, então você aciona o fluxo de mudança.
Algo assim pode ser possível.
Dito isso, se eu tivesse que adicionar código para excluir arquivos, classificar antes do diff, etc., provavelmente ficaria bastante complexo, então não quero muito fazer isso.

Enquanto escrevia, pensei...

Não preciso executar find; posso simplesmente redirecionar ls -laR para /tmp e pegar a diferença.
Mas por que o git parece mais leve...? Se eu começar a pensar nisso, terei que começar a desconstruir o Git, então por hoje é só.

Até a próxima, por favor.