Conserver un historique de toutes les modifications apportées à un fichier texte

Donnez git une chance

Je ne vois pas pourquoi c'est un problème d'utiliser un outil puissant. Écrivez simplement un script bash simple qui exécute git périodiquement (via cron ou systemd minuteries); générer automatiquement des messages de validation, etc.

Comme d'autres l'ont souligné dans les commentaires, il est - bien sûr - possible de créer un référentiel local (voir ici et là pour plus de détails).

Si vous préférez héberger votre propre référentiel distant, vous devrez configurer un "dépôt nu". Les deux git init et git clone accepter un --bare arguments.

Sauvegarde Borg

Je peux également recommander la sauvegarde de borg. Il vous offre :

• Horodatages
• borg diff (comparer entre les instantanés)
• Élagage (débarrassez-vous des instantanés plus anciens - disons que vous voulez un instantané pour le mois en cours tous les jours, mais sinon un seul par mois)
• Chiffrement (facultatif)
• Compression (facultatif)
• et bien plus encore...

Ce qui est cool, c'est qu'il est très flexible - il est facile à configurer mais vous offre de nombreuses options si vous le souhaitez.

Une fois, j'ai écrit un guide de démarrage rapide qui pourrait être utile.

Vous pouvez procéder de plusieurs manières :

• Vim
• Emacs
• Git
• Bash/Outil externe
• Git-annex (solution tout-en-un)

Qui sont tous détaillés ici :

• Si vous voulez faire cela dans Vim :

Ensuite, je recommanderais d'utiliser l'historique d'annulation, qui non seulement (comme son nom l'indique) se rapporte à l'acte de undo une action dans l'éditeur Vim, mais aussi celle que vous enregistrez. Plus ici.

Ajouter ce qui suit à votre .vimrc :

let vimDir = '$HOME/.vim'
let &runtimepath.=','.vimDir

" Keep undo history across sessions by storing it in a file
if has('persistent_undo')
    let myUndoDir = expand(vimDir . '/undodir')
" Create dirs
    call system('mkdir ' . vimDir)
    call system('mkdir ' . myUndoDir)
    let &undodir = myUndoDir
    set undofile
endif

Faire en sorte que chaque modification/annulation soit conservée en permanence dans le répertoire undodir sous votre vimDir local , qui est par défaut soit .vim dans votre répertoire personnel, ou d'autres mentionnés dans la sortie de :version ou --version sur la ligne de commande.

Pour encore plus de contrôle sur votre historique d'annulation, je vous recommande également d'utiliser Undotree pour compléter l'expérience.

• Si vous prévoyez de le faire sur Emacs :

Il existe des packages nommés similaires appelés Undotree, qui font des choses similaires. Plus d'informations sur l'historique d'annulation ici.

• Si vous préférez un Git solution :

Je recommanderais d'utiliser git-autocommit, qui est un petit script bash, avec git comme seules dépendances, qui surveille le répertoire git actuel (où vous le lancez) pour tout nouveau fichier/ou fichier modifié, et validez-les.

Étant donné la nature de Git il conserve toutes les modifications apportées au fichier, et même s'il ne conviendrait pas à un projet de production/sérieux, c'est une solution utile si cela ne vous dérange pas de ne pas avoir de message de validation/message de validation générique (que vous pouvez toujours modifier/ajouter plus tard).

Lancez-le après avoir navigué sur le répertoire git voulu (qui est d'abord fait avec git init sur un répertoire spécifique, plus d'infos sur le manuel officiel) comme ceci :

screen -dmS namehere git-autocommit -i 1 -V

si vous utilisez screen , pour tmux :

tmux new -n namehere git-autocommit -i 1 -V

sinon :

git-autocommit -i 1 -V

suffira si vous préférez ne pas l'arrière-plan.

• Si vous préférez un Bash solution :

Je recommanderais d'utiliser inotify-tools ou plus précisément inotifywatch qui peut détecter et (comme son nom l'indique) surveiller un fichier/répertoire pour les modifications, sur lesquelles vous pouvez ensuite agir (comme l'enregistrer ailleurs, etc.).

Voici le drapeau à utiliser avec inotifywatch :

inotifywait -r -m -q -e close_write --format %w%f yourdirectorypathhere

et ici un exemple Bash script utilisant ce qui précède :

#!/bin/bash
inotifywait -r -m -q -e close_write --format %w%f directorytowatch | while IFS= read -r file; do

    process $file
done

Où process peut être tout ce que vous voulez, comme tar si vous voulez faire une sauvegarde sur modification de fichier, ou avec rclone si vous voulez le télécharger quelque part...

• Si vous souhaitez une solution tout-en-un :

Je recommanderais git-annex qui englobent non seulement Git mais de nombreux autres outils externes, comme inotify-tools , bash , tar , rclone , borg etc.

Plus d'infos ici.

Si vous avez envie de lire le wiki/forum plus tard, vous pouvez également le cloner localement, pour une lecture hors ligne :

git clone git://git-annex.branchable.com

pour le site, le forum (tout est en démarque, donc c'est très rapide à télécharger...), et la base de code (c'est en Haskell !) etc

Une autre approche, qui couvrira tous les fichiers d'un système de fichiers donné, consiste à utiliser un système de fichiers structuré en journal tel que NILFS.

Ces systèmes de fichiers ajoutent des modifications, ils ne remplacent pas les données. Cela équivaut en fait à un instantané continu (ou plutôt à un point de contrôle) et vous permet de revisiter le système de fichiers à différents moments dans le passé. Les points de contrôle plus anciens sont susceptibles d'être ramassés une fois qu'ils ont atteint un certain âge, mais les points de contrôle peuvent être transformés en instantanés permanents, et il est possible d'automatiser cela, par exemple pour conserver un instantané par heure le mois dernier, puis un par jour. pendant six mois, puis un par semaine etc.

NILFS est bien pris en charge sur Linux et est assez efficace lorsqu'il est utilisé pour /home .