* Chezmoi

  Uno strumento che negli ultimi tempi è argomento di molti articoli e/o video.

  Si tratta di uno software scritto in GO e che quindi, oltre ad offrire il vantaggio di non avere
  dipendenze esterne, è effettivamente multi-piattaforma potendo funzionare sui canonici Linux/MacOS,
  ma anche su Windows.
  
* La filosofia

  Chezmoi si differenzia un po' dal resto degli strumenti in quanto tende a non usare i link simbolici
  ma una "copia" dei files.

* Installazione

  Sul sito github di Chezmoi c'è un comando da copiare che consente l'installazione del programma
  (e anche la clonazione del repository).

  Il comando può essere scomposto andando ad utilizzare soltanto la parte relativa al download e
  all'installazione del programma.

  L'installazione può avvenire con diversi metodi. Il metodo che funziona sempre è quello di usare
  lo script presente su Github. Qui sarà mostrato lo script per Linux basato su "sh", ma è possibile
  usare anche lo script basato su "powershell" (vedere la documentazione).
  
** Prima installazione con repository da creare
   
   Se non diversamente indicato lo script di installazione posiziona il programma nella ~$HOME/.bin~,
   posizione che a me non piace particolarmente; preferisco che l'eseguibile venga posizionato nella
   ~$HOME/.local/bin~ che un po' tutte le versioni recenti di Linux hanno già nel path.

   Per installare il programma nella ~$HOME/.local/bin~ occorre eseguire quindi il comando così modificato:
   #+begin_example
     sh -c "$(curl -fsLS git.io/chezmoi)" -- -b $HOME/.local/bin
   #+end_example

** Installazione con clone del repository esistente

   Qui la situazione è praticamente quella descritta nella documentazione.

   L'unica differenza continua ad essere la preferenza personale nel voler installare l'eseguibile
   nella ~$HOME/.local/bin~

   Assumendo che il repository sia su Github:
   #+begin_example
     sh -c "$(curl -fsLS git.io/chezmoi)" -- -b $HOME/.local/bin init --apply <github-username>
   #+end_example

   La connessione al repository avviene normalmente usando il protocollo HTTPS, è possibile usare
   il protocollo SSH usando il parametro aggiuntivo ~--ssh~.
   
   Il pattern ~<github-username>~ può assumere, secondo la documentazione:

   | Pattern          | HTTPS Repo                           | SSH repo                         |
   |------------------+--------------------------------------+----------------------------------|
   | user             | https://github.com/user/dotfiles.git | git@github.com:user/dotfiles.git |
   | user/repo        | https://github.com/user/repo.git     | git@github.com:user/repo.git     |
   | site/user/repo   | https://site/user/repo.git           | git@site:user/repo.git           |
   | ~sr.ht/user      | https://git.sr.ht/~user/dotfiles     | git@git.sr.ht:~user/dotfiles.git |
   | ~sr.ht/user/repo | https://git.sr.ht/~user/repo         | git@git.sr.ht:~/user/repo.git    |

* Partendo da un repository esistente

  Una volta installato il programma e clonato il repository l'unica azione da eseguire per avere
  la configurazione dei dotfiles funzionante è:

  #+begin_example
    chezmoi apply
  #+end_example

  E' possibile aggiungere al comando dei parametri, tra questi sono utili:
  - ~-v~ :: verbose, mostra il dettaglio delle operazioni effettuate
  - ~-n~ :: dry-run, esegue un "giro di prova" senza applicare effettivamente le modifiche
  
* Aggiunta di elementi alla gestione

  Per aggiungere un nuovo dotfile alla gestione si usa il comando ~chezmoi add <path/to/file>~

  Assumendo di avere i dotfiles già presenti nella nostra home e volendoli aggiungere alla gestione
  possiamo fare:

** Emacs

   Con questi comandi si aggiungo in files e le directories alla gestione
   
   #+begin_example
     chezmoi add ~/.emacs.d/early-init.el
     chezmoi add ~/.emacs.d/init.el
     chezmoi add ~/.emacs.d/gb-init.org
     chezmoi add ~/.emacs.d/img
     chezmoi add ~/.emacs.d/snippets
   #+end_example

   Per vedere le modifiche che chezmoi applicherà si può usare il comando

   #+begin_example
     chezmoi diff
   #+end_example

   Per applicare le modifiche:

   #+begin_example
     chezmoi -v apply
   #+end_example

   A questo punto abbiamo operato le varie modifiche al repository locale. Chezmoi non interagisce
   direttamente con git, per cui occorre entrare nella directory del repository ed eseguire sia il commit
   che il push:

   #+begin_example
     chezmoi cd # apre una shell posizionandosi nella directory del repository
     git add . # aggiungiamo il tutto allo stage
     git commit -m "Aggiunto Emacs"
     exit # esce dalla shell creata da chezmoi
   #+end_example

   Per aggiornare poi il repository remoto:

   #+begin_example
     chezmoi cd
     git push origin master
     exit
   #+end_example

** Vim

   #+begin_example
     chezmoi add ~/.vimrc
     chezmoi add ~/.vim
     chezmoi -v apply
     chezmoi cd
     git add .
     git commit -m "Aggiunto Vim"
     git push origin master
     exit
   #+end_example

** Git

   Nel repository di esempio si è usato il meccanismo dei template per configurare l'utente di Git
   (in .gitconfig) in base all'hostname.