Faire de la validation actuelle la seule validation (initiale) dans un référentiel Git?

J'ai actuellement un référentiel Git local, que je pousse vers un référentiel Github.

Le référentiel local a environ 10 validations, et le référentiel Github en est un double synchronisé.

Ce que je voudrais faire, c'est supprimer TOUT l'historique des versions du référentiel Git local, de sorte que le contenu actuel du référentiel apparaisse comme le seul commit (et donc les anciennes versions de fichiers dans le référentiel ne sont pas stockées).

J'aimerais ensuite transmettre ces modifications à Github.

J'ai étudié le rebase de Git, mais cela semble être plus adapté à la suppression de versions spécifiques. Une autre solution potentielle est de supprimer le référentiel local et d'en créer un nouveau - bien que cela créerait probablement beaucoup de travail!

ETA: Il existe des répertoires / fichiers spécifiques qui ne sont pas suivis - si possible, je voudrais maintenir le non-suivi de ces fichiers.

Voici l'approche par force brute. Il supprime également la configuration du référentiel.

Remarque : cela ne fonctionne PAS si le référentiel contient des sous-modules! Si vous utilisez des sous-modules, vous devez utiliser par exemple un rebase interactif

Étape 1: supprimer tout l'historique ( assurez-vous d'avoir une sauvegarde, cela ne peut pas être annulé )

cat .git/config  # note <github-uri>
rm -rf .git

Étape 2: reconstruire le référentiel Git avec uniquement le contenu actuel

git init
git add .
git commit -m "Initial commit"

Étape 3: appuyez sur GitHub.

git remote add origin <github-uri>
git push -u --force origin master

La seule solution qui fonctionne pour moi (et fait fonctionner les sous-modules) est

git checkout --orphan newBranch
git add -A  # Add all files and commit them
git commit
git branch -D master  # Deletes the master branch
git branch -m master  # Rename the current branch to master
git push -f origin master  # Force push master branch to github
git gc --aggressive --prune=all     # remove the old files

La suppression .git/cause toujours d'énormes problèmes lorsque j'ai des sous-modules. L'utilisation git rebase --rootme causerait en quelque sorte des conflits (et prendrait longtemps car j'avais beaucoup d'histoire).

Voici mon approche privilégiée:

git branch new_branch_name $(echo "commit message" | git commit-tree HEAD^{tree})

Cela va créer une nouvelle branche avec un commit qui ajoute tout dans HEAD. Cela ne change rien d'autre, donc c'est complètement sûr.

L'autre option, qui pourrait s'avérer être beaucoup de travail si vous avez beaucoup de commits, est une rebase interactive (en supposant que votre version git soit> = 1.7.12):git rebase --root -i

Lorsqu'une liste de validations s'affiche dans votre éditeur:

• Remplacez «choisir» par «reformuler» pour le premier commit
• Changer "choisir" en "corriger" tous les autres commit

Sauver et fermer. Git va commencer le rebasage.

À la fin, vous auriez un nouveau commit racine qui est une combinaison de tous ceux qui l'ont suivi.

L'avantage est que vous n'avez pas à supprimer votre référentiel et si vous avez des doutes, vous avez toujours un repli.

Si vous voulez vraiment nuancer votre historique, réinitialisez master à ce commit et supprimez toutes les autres branches.

Variante de la méthode proposée par Larsmans :

Enregistrez votre liste de non-traces:

git ls-files --others --exclude-standard > /tmp/my_untracked_files

Enregistrez votre configuration git:

mv .git/config /tmp/

Effectuez ensuite les premières étapes de larsmans:

rm -rf .git
git init
git add .

Restaurez votre configuration:

mv /tmp/config .git/

Détachez vos fichiers non suivis:

cat /tmp/my_untracked_files | xargs -0 git rm --cached

Engagez ensuite:

git commit -m "Initial commit"

Et enfin, poussez vers votre référentiel:

git push -u --force origin master

Vous trouverez ci-dessous un script adapté de la réponse de @Zeelot. Il devrait supprimer l'historique de toutes les branches, pas seulement de la branche principale:

for BR in $(git branch); do   
  git checkout $BR
  git checkout --orphan ${BR}_temp
  git commit -m "Initial commit"
  git branch -D $BR
  git branch -m $BR
done;
git gc --aggressive --prune=all

Cela a fonctionné pour mes besoins (je n'utilise pas de sous-modules).

Vous pouvez utiliser des clones peu profonds (git> 1.9):

git clone --depth depth remote-url

Pour en savoir plus: http://blogs.atlassian.com/2014/05/handle-big-repositories-git/

git filter-branch est l'outil de chirurgie majeure.

git filter-branch --parent-filter true -- @^!

--parent-filterobtient les parents sur stdin et devrait imprimer les parents réécrits sur stdout; unix truesort avec succès et n'imprime rien, donc: pas de parents. @^!est l' abréviation de Git pour "le responsable principal mais pas l'un de ses parents". Supprimez ensuite toutes les autres références et appuyez à loisir.

Supprimez simplement le dépôt Github et créez-en un nouveau. De loin l'approche la plus rapide, la plus simple et la plus sûre. Après tout, qu'avez-vous à gagner à exécuter toutes ces commandes dans la solution acceptée lorsque tout ce que vous voulez, c'est la branche principale avec un seul commit?

La méthode ci-dessous est exactement reproductible, il n'est donc pas nécessaire de réexécuter le clone si les deux côtés étaient cohérents, il suffit d'exécuter le script de l'autre côté également.

git log -n1 --format=%H >.git/info/grafts
git filter-branch -f
rm .git/info/grafts

Si vous souhaitez ensuite le nettoyer, essayez ce script:

http://sam.nipl.net/b/git-gc-all-ferocious

J'ai écrit un script qui "tue l'historique" pour chaque branche du référentiel:

http://sam.nipl.net/b/git-kill-history

voir aussi: http://sam.nipl.net/b/confirm

Ce que je voudrais faire, c'est supprimer TOUT l'historique des versions du référentiel Git local, de sorte que le contenu actuel du référentiel apparaisse comme le seul commit (et donc les anciennes versions de fichiers dans le référentiel ne sont pas stockées).

Une réponse plus conceptuelle:

git récupère automatiquement les anciens commits si aucune balise / branche / référence ne pointe vers eux. Il vous suffit donc de supprimer toutes les balises / branches et de créer un nouveau commit orphelin, associé à n'importe quelle branche - par convention, vous laisseriez la branchemaster pointer vers ce commit.

Les anciens commits inaccessibles ne seront alors plus jamais vus par quiconque à moins qu'ils ne creusent avec des commandes git de bas niveau. Si cela vous suffit, je m'arrête là et je laisse le GC automatique faire son travail quand il le souhaite. Si vous voulez vous en débarrasser tout de suite, vous pouvez utiliser git gc(éventuellement avec --aggressive --prune=all). Pour le référentiel git distant, il n'y a aucun moyen pour vous de forcer cela, sauf si vous avez un accès shell à leur système de fichiers.

Voici:

#!/bin/bash
#
# By Zibri (2019)
#
# Usage: gitclean username password giturl
#
gitclean () 
{ 
    odir=$PWD;
    if [ "$#" -ne 3 ]; then
        echo "Usage: gitclean username password giturl";
        return 1;
    fi;
    temp=$(mktemp -d 2>/dev/null /dev/shm/git.XXX || mktemp -d 2>/dev/null /tmp/git.XXX);
    cd "$temp";
    url=$(echo "$3" |sed -e "s/[^/]*\/\/\([^@]*@\)\?\.*/\1/");
    git clone "https://$1:$2@$url" && { 
        cd *;
        for BR in "$(git branch|tr " " "\n"|grep -v '*')";
        do
            echo working on branch $BR;
            git checkout $BR;
            git checkout --orphan $(basename "$temp"|tr -d .);
            git add -A;
            git commit -m "Initial Commit" && { 
                git branch -D $BR;
                git branch -m $BR;
                git push -f origin $BR;
                git gc --aggressive --prune=all
            };
        done
    };
    cd $odir;
    rm -rf "$temp"
}

Également hébergé ici: https://gist.github.com/Zibri/76614988478a076bbe105545a16ee743

J'ai résolu un problème similaire en supprimant simplement le .gitdossier de mon projet et en réintégrant le contrôle de version via IntelliJ. Remarque: le .gitdossier est masqué. Vous pouvez l'afficher dans le terminal avec ls -a, puis le supprimer à l'aide de rm -rf .git.

Pour cela, utilisez la commande Shallow Clone git clone --depth 1 URL - Il clone uniquement le HEAD actuel du référentiel

Pour supprimer le dernier commit de git, vous pouvez simplement exécuter

git reset --hard HEAD^ 

Si vous supprimez plusieurs validations par le haut, vous pouvez exécuter

git reset --hard HEAD~2 

pour supprimer les deux derniers commits. Vous pouvez augmenter le nombre pour supprimer encore plus de validations.

Plus d'infos ici.

Git tutoturial fournit ici de l' aide sur la façon de purger le référentiel:

vous souhaitez supprimer le fichier de l'historique et l'ajouter au .gitignore pour vous assurer qu'il n'est pas réaffecté accidentellement. Pour nos exemples, nous allons supprimer Rakefile du référentiel GitHub gem.

git clone https://github.com/defunkt/github-gem.git

cd github-gem

git filter-branch --force --index-filter \
  'git rm --cached --ignore-unmatch Rakefile' \
  --prune-empty --tag-name-filter cat -- --all

Maintenant que nous avons supprimé le fichier de l'historique, assurons-nous de ne pas le commettre à nouveau accidentellement.

echo "Rakefile" >> .gitignore

git add .gitignore

git commit -m "Add Rakefile to .gitignore"

Si vous êtes satisfait de l'état du référentiel, vous devez forcer les modifications pour écraser le référentiel distant.

git push origin master --force