Pour une raison quelconque, je n'ai qu'un seul référentiel à utiliser.
Mais j'ai plusieurs projets, y compris des javaprojets php scriptset des Androidprojets d'applications.

Maintenant, mon problème est que je dois les mettre dans différents sous-dossiers à l'intérieur du référentiel.
J'utilise différents IDE, vous savez, chaque IDE peut avoir un espace de travail en lui-même.

Qui peut me dire une meilleure pratique pour résoudre le problème?

Alors que la plupart des gens vous diront de simplement utiliser plusieurs référentiels, je pense qu'il vaut la peine de mentionner qu'il existe d'autres solutions.

Solution 1

Un référentiel unique peut contenir plusieurs branches indépendantes , appelées branches orphelines . Les branches orphelines sont complètement séparées les unes des autres; ils ne partagent pas d'histoires.

git checkout --orphan BRANCHNAME

Cela crée une nouvelle branche, sans rapport avec votre branche actuelle. Chaque projet doit être dans sa propre branche orpheline.

Maintenant, pour une raison quelconque, git a besoin d'un peu de nettoyage après une extraction orpheline.

rm .git/index
rm -r *

Assurez-vous que tout est validé avant de supprimer

Une fois la branche orpheline propre, vous pouvez l'utiliser normalement.

Solution 2

Évitez tous les tracas des branches orphelines. Créez deux référentiels indépendants et transférez-les vers la même télécommande. Utilisez simplement des noms de branche différents pour chaque dépôt.

# repo 1
git push origin master:master-1

# repo 2
git push origin master:master-2

Solution 3

C'est pour utiliser un seul répertoire pour plusieurs projets. J'utilise cette technique pour certains projets étroitement liés où j'ai souvent besoin de transférer des modifications d'un projet à un autre. C'est similaire à l'idée des branches orphelines mais les branches n'ont pas besoin d'être orphelines. Démarrez simplement tous les projets à partir du même état de répertoire vide.

Démarrer tous les projets à partir d'un répertoire vide validé

Ne vous attendez pas à des merveilles de cette solution. Comme je le vois, vous allez toujours avoir des ennuis avec les fichiers non suivis. Git n'a pas vraiment la moindre idée de ce qu'il faut faire avec eux et donc s'il y a des fichiers intermédiaires générés par un compilateur et ignorés par votre fichier .gitignore, il est probable qu'ils seront laissés en suspens de temps en temps si vous essayez d'échanger rapidement entre - par exemple - votre projet logiciel et un projet de thèse de doctorat.

Cependant voici le plan. Commencez comme vous devriez démarrer tous les projets git, en validant le référentiel vide, puis démarrez tous vos projets à partir du même état de répertoire vide. De cette façon, vous êtes certain que les deux lots de fichiers sont assez indépendants. Aussi, donnez à vos branches un nom propre et n'utilisez pas paresseusement "master". Vos projets doivent être séparés, alors donnez-leur des noms appropriés.

Les commits Git (et donc les balises et les branches) stockent fondamentalement l'état d'un répertoire et de ses sous-répertoires et Git n'a aucune idée si ceux-ci font partie du même projet ou de différents projets, donc il n'y a vraiment aucun problème pour git stocker différents projets dans le même référentiel. Le problème est alors pour vous d'effacer les fichiers non suivis d'un projet lors de l'utilisation d'un autre, ou de séparer les projets plus tard.

Créer un référentiel vide

cd some_empty_directory
git init
touch .gitignore
git add .gitignore
git commit -m empty
git tag EMPTY

Démarrez vos projets à vide.

Travaillez sur un projet.

git branch software EMPTY
git checkout software
echo "array board[8,8] of piece" > chess.prog

git add chess.prog 
git commit -m "chess program"

Commencer un autre projet

quand tu veux.

git branch thesis EMPTY
git checkout thesis
echo "the meaning of meaning" > philosophy_doctorate.txt
git add philosophy_doctorate.txt 
git commit -m "Ph.D"

Basculer d'avant en arrière

Revenez et avancez entre les projets quand vous le souhaitez. Cet exemple remonte au projet de logiciel d'échecs.

git checkout software
echo "while not end_of_game do make_move()" >> chess.prog
git add chess.prog 
git commit -m "improved chess program"

Les fichiers non suivis sont ennuyeux

Vous serez cependant ennuyé par les fichiers non suivis lors de l'échange entre les projets / branches.

touch untracked_software_file.prog
git checkout thesis 
ls
    philosophy_doctorate.txt  untracked_software_file.prog

Ce n'est pas un problème insurmontable

Par définition, git ne sait pas vraiment quoi faire des fichiers non suivis et c'est à vous de les gérer. Vous pouvez empêcher le transfert de fichiers non suivis d'une branche à une autre comme suit.

git checkout EMPTY 
ls
    untracked_software_file.prog
rm -r *
    (directory is now really empty, apart from the repository stuff!)
git checkout thesis
ls
    philosophy_doctorate.txt

En nous assurant que le répertoire était vide avant d'extraire notre nouveau projet, nous nous sommes assurés qu'il n'y avait pas de fichiers non suivis suspendus d'un autre projet.

Un raffinement

$ GIT_AUTHOR_DATE='2001-01-01:T01:01:01' GIT_COMMITTER_DATE='2001-01-01T01:01:01' git commit -m empty

Si les mêmes dates sont spécifiées lors de la validation d'un référentiel vide, les validations de référentiel vide créées indépendamment peuvent avoir le même code SHA1. Cela permet à deux référentiels d'être créés indépendamment, puis fusionnés en un seul arbre avec une racine commune dans un référentiel plus tard.

Exemple

# Create thesis repository. 
# Merge existing chess repository branch into it

mkdir single_repo_for_thesis_and_chess
cd single_repo_for_thesis_and_chess
git init
touch .gitignore
git add .gitignore
GIT_AUTHOR_DATE='2001-01-01:T01:01:01' GIT_COMMITTER_DATE='2001-01-01:T01:01:01' git commit -m empty
git tag EMPTY
echo "the meaning of meaning" > thesis.txt
git add thesis.txt
git commit -m "Wrote my PH.D"
git branch -m master thesis

# It's as simple as this ...
git remote add chess ../chessrepository/.git
git fetch chess chess:chess

Résultat

Utiliser des sous-répertoires par projet?

Cela peut également aider si vous conservez vos projets dans des sous-répertoires lorsque cela est possible, par exemple au lieu d'avoir des fichiers

chess.prog
philosophy_doctorate.txt 

avoir

chess/chess.prog
thesis/philosophy_doctorate.txt 

Dans ce cas, votre fichier logiciel non suivi sera chess/untracked_software_file.prog. Lorsque vous travaillez dans le thesisrépertoire, vous ne devriez pas être dérangé par des fichiers de programme d'échecs non suivis, et vous pouvez trouver des occasions où vous pouvez travailler sans effacer les fichiers non suivis d'autres projets.

De plus, si vous souhaitez supprimer des fichiers non suivis d'autres projets, il sera plus rapide (et moins sujet aux erreurs) de vider un répertoire indésirable que de supprimer les fichiers indésirables en sélectionnant chacun d'eux.

Les noms de succursales peuvent inclure des caractères «/»

Vous voudrez peut-être nommer vos branches quelque chose comme

project1/master
project1/featureABC
project2/master
project2/featureXYZ

J'utiliserais git submodules.

regardez ici le dépôt Git dans un dépôt Git

En février 2019, je suggérerais Monorepos

• Lerna
• Bit