annulla il sottomodulo di un sottomodulo git

Come posso annullare la sottomodulazione di un sottomodulo git (riportare tutto il codice nel core)?

Come in "dovrei" io, come in "Migliore procedura" ...

Se tutto ciò che desideri è inserire il codice del tuo sottomodulo nel repository principale, devi solo rimuovere il sottomodulo e aggiungere nuovamente i file nel repository principale:

git rm --cached submodule_path # delete reference to submodule HEAD (no trailing slash)
git rm .gitmodules             # if you have more than one submodules,
                               # you need to edit this file instead of deleting!
rm -rf submodule_path/.git     # make sure you have backup!!
git add submodule_path         # will add files instead of commit reference
git commit -m "remove submodule"

Se vuoi anche preservare la cronologia del sottomodulo, puoi fare un piccolo trucco: "unisci" il sottomodulo nel repository principale in modo che il risultato sia lo stesso di prima, tranne che i file del sottomodulo sono ora nella repository principale.

Nel modulo principale dovrai fare quanto segue:

# Fetch the submodule commits into the main repository
git remote add submodule_origin git://url/to/submodule/origin
git fetch submodule_origin

# Start a fake merge (won't change any files, won't commit anything)
git merge -s ours --no-commit submodule_origin/master

# Do the same as in the first solution
git rm --cached submodule_path # delete reference to submodule HEAD
git rm .gitmodules             # if you have more than one submodules,
                               # you need to edit this file instead of deleting!
rm -rf submodule_path/.git     # make sure you have backup!!
git add submodule_path         # will add files instead of commit reference

# Commit and cleanup
git commit -m "removed submodule"
git remote rm submodule_origin

Il repository risultante sembrerà un po 'strano: ci sarà più di un commit iniziale. Ma non causerà alcun problema per Git.

In questa seconda soluzione avrai il grande vantaggio di poter ancora eseguire git blame o git log sui file originariamente presenti nei sottomoduli. In effetti quello che hai fatto qui è stato rinominare molti file all'interno di un repository e git dovrebbe rilevare automaticamente questo. Se hai ancora problemi con git log, prova alcune opzioni (--follow, -M, -C) che migliorano il rinominare / copiare il rilevamento.

Da git 1.8.5 (novembre 2013 ) ( senza mantenere la cronologia del sottomodulo ):

mv yoursubmodule yoursubmodule_tmp
git submodule deinit yourSubmodule
git rm yourSubmodule
mv yoursubmodule_tmp yoursubmodule
git add yoursubmodule

Quello sarà:

• annullare la registrazione e scaricare (ovvero eliminare il contenuto di ) il sottomodulo ( deinit, quindi il mv primo ),
• ripulisci il .gitmodulesfor you ( rm),
• e rimuovere la voce speciale che rappresenta quel sottomodulo SHA1 nell'indice del repository principale ( rm).

Una volta completata la rimozione del sottomodulo ( deinite git rm), è possibile rinominare la cartella con il nome originale e aggiungerla al repository git come una normale cartella.

Nota: se il sottomodulo è stato creato da un vecchio Git (<1.8), potrebbe essere necessario rimuovere la .gitcartella nidificata all'interno del sottomodulo stesso, come commentato da Simon East

Se è necessario conservare la cronologia del sottomodulo, consultare la risposta di jsears , che utilizza .git filter-branch

Ho creato uno script che tradurrà un sottomodulo in una semplice directory, pur mantenendo tutta la cronologia dei file. Non soffre dei git log --follow <file>problemi di cui soffrono le altre soluzioni. È anche una semplice chiamata a una riga che fa tutto il lavoro per te. G'luck.

Si basa sull'eccellente lavoro di Lucas Jenß, descritto nel suo post sul blog " Integrazione di un sottomodulo nel repository principale ", ma automatizza l'intero processo e ripulisce alcuni altri casi angolari.

L'ultimo codice verrà mantenuto con correzioni di bug su github all'indirizzo https://github.com/jeremysears/scripts/blob/master/bin/git-submodule-rewrite , ma per motivi di protocollo di risposta stackoverflow corretto, ho incluso il soluzione nella sua interezza di seguito.

Uso:

$ git-submodule-rewrite <submodule-name>

git-modulo-riscrivere:

#!/usr/bin/env bash

# This script builds on the excellent work by Lucas Jenß, described in his blog
# post "Integrating a submodule into the parent repository", but automates the
# entire process and cleans up a few other corner cases.
# https://x3ro.de/2013/09/01/Integrating-a-submodule-into-the-parent-repository.html

function usage(){
  echo "Merge a submodule into a repo, retaining file history."
  echo "Usage: $0 <submodule-name>"
  echo ""
  echo "options:"
  echo "  -h, --help                Print this message"
  echo "  -v, --verbose             Display verbose output"
}

function abort {
    echo "$(tput setaf 1)$1$(tput sgr0)"
    exit 1
}

function request_confirmation {
    read -p "$(tput setaf 4)$1 (y/n) $(tput sgr0)"
    [ "$REPLY" == "y" ] || abort "Aborted!"
}

function warn() {
  cat << EOF
    This script will convert your "${sub}" git submodule into
    a simple subdirectory in the parent repository while retaining all
    contents and file history.

    The script will:
      * delete the ${sub} submodule configuration from .gitmodules and
        .git/config and commit it.
      * rewrite the entire history of the ${sub} submodule so that all
        paths are prefixed by ${path}.
        This ensures that git log will correctly follow the original file
        history.
      * merge the submodule into its parent repository and commit it.

    NOTE: This script might completely garble your repository, so PLEASE apply
    this only to a fresh clone of the repository where it does not matter if
    the repo is destroyed.  It would be wise to keep a backup clone of your
    repository, so that you can reconstitute it if need be.  You have been
    warned.  Use at your own risk.

EOF

  request_confirmation "Do you want to proceed?"
}

function git_version_lte() {
  OP_VERSION=$(printf "%03d%03d%03d%03d" $(echo "$1" | tr '.' '\n' | head -n 4))
  GIT_VERSION=$(git version)
  GIT_VERSION=$(printf "%03d%03d%03d%03d" $(echo "${GIT_VERSION#git version}" | tr '.' '\n' | head -n 4))
  echo -e "${GIT_VERSION}\n${OP_VERSION}" | sort | head -n1
  [ ${OP_VERSION} -le ${GIT_VERSION} ]
}

function main() {

  warn

  if [ "${verbose}" == "true" ]; then
    set -x
  fi

  # Remove submodule and commit
  git config -f .gitmodules --remove-section "submodule.${sub}"
  if git config -f .git/config --get "submodule.${sub}.url"; then
    git config -f .git/config --remove-section "submodule.${sub}"
  fi
  rm -rf "${path}"
  git add -A .
  git commit -m "Remove submodule ${sub}"
  rm -rf ".git/modules/${sub}"

  # Rewrite submodule history
  local tmpdir="$(mktemp -d -t submodule-rewrite-XXXXXX)"
  git clone "${url}" "${tmpdir}"
  pushd "${tmpdir}"
  local tab="$(printf '\t')"
  local filter="git ls-files -s | sed \"s/${tab}/${tab}${path}\//\" | GIT_INDEX_FILE=\${GIT_INDEX_FILE}.new git update-index --index-info && mv \${GIT_INDEX_FILE}.new \${GIT_INDEX_FILE}"
  git filter-branch --index-filter "${filter}" HEAD
  popd

  # Merge in rewritten submodule history
  git remote add "${sub}" "${tmpdir}"
  git fetch "${sub}"

  if git_version_lte 2.8.4
  then
    # Previous to git 2.9.0 the parameter would yield an error
    ALLOW_UNRELATED_HISTORIES=""
  else
    # From git 2.9.0 this parameter is required
    ALLOW_UNRELATED_HISTORIES="--allow-unrelated-histories"
  fi

  git merge -s ours --no-commit ${ALLOW_UNRELATED_HISTORIES} "${sub}/master"
  rm -rf tmpdir

  # Add submodule content
  git clone "${url}" "${path}"
  rm -rf "${path}/.git"
  git add "${path}"
  git commit -m "Merge submodule contents for ${sub}"
  git config -f .git/config --remove-section "remote.${sub}"

  set +x
  echo "$(tput setaf 2)Submodule merge complete. Push changes after review.$(tput sgr0)"
}

set -euo pipefail

declare verbose=false
while [ $# -gt 0 ]; do
    case "$1" in
        (-h|--help)
            usage
            exit 0
            ;;
        (-v|--verbose)
            verbose=true
            ;;
        (*)
            break
            ;;
    esac
    shift
done

declare sub="${1:-}"

if [ -z "${sub}" ]; then
  >&2 echo "Error: No submodule specified"
  usage
  exit 1
fi

shift

if [ -n "${1:-}" ]; then
  >&2 echo "Error: Unknown option: ${1:-}"
  usage
  exit 1
fi

if ! [ -d ".git" ]; then
  >&2 echo "Error: No git repository found.  Must be run from the root of a git repository"
  usage
  exit 1
fi

declare path="$(git config -f .gitmodules --get "submodule.${sub}.path")"
declare url="$(git config -f .gitmodules --get "submodule.${sub}.url")"

if [ -z "${path}" ]; then
  >&2 echo "Error: Submodule not found: ${sub}"
  usage
  exit 1
fi

if ! [ -d "${path}" ]; then
  >&2 echo "Error: Submodule path not found: ${path}"
  usage
  exit 1
fi

main

1. git rm --cached the_submodule_path
2. rimuovere la sezione del sottomodulo dal .gitmodulesfile o, se è l'unico sottomodulo, rimuovere il file.
3. eseguire un commit "xyz sottomodulo rimosso"
4. git add the_submodule_path
5. un altro commit "aggiunta base di codice di xyz"

Non ho ancora trovato un modo più semplice. Puoi comprimere 3-5 in un solo passaggio tramite git commit -a- questione di gusti.

Molte risposte qui, ma tutte sembrano essere eccessivamente complesse e probabilmente non fanno quello che vuoi. Sono sicuro che molte persone vogliono mantenere la loro storia.

Per questo esempio il repository principale sarà git@site.com:main/main.gite il repository sottomodulo sarà git@site.com:main/child.git. Ciò presuppone che il sottomodulo si trovi nella directory principale del repository principale. Regola le istruzioni secondo necessità.

Inizia clonando il repository principale e rimuovendo il vecchio sottomodulo.

git clone git@site.com:main/main.git
git submodule deinit child
git rm child
git add --all
git commit -m "remove child submodule"

Ora aggiungeremo i repository secondari a monte al repository principale.

git remote add upstream git@site.com:main/child.git
git fetch upstream
git checkout -b merge-prep upstream/master

Il passaggio successivo presuppone che si desideri spostare i file sul ramo di preparazione-unione nella stessa posizione del sottomodulo precedente, sebbene sia possibile modificare facilmente la posizione modificando il percorso del file.

mkdir child

sposta tutte le cartelle e tutti i file tranne la cartella .git nella cartella secondaria.

git add --all
git commit -m "merge prep"

Ora puoi semplicemente unire nuovamente i tuoi file nel ramo principale.

git checkout master
git merge merge-prep # --allow-unrelated-histories merge-prep flag may be required 

Guardati intorno e assicurati che tutto appaia bene prima di correre git push

L'unica cosa che devi ricordare ora è che git log non segue di default i file spostati, ma eseguendo git log --follow filenamepuoi vedere la cronologia completa dei tuoi file.

Ci è successo che abbiamo creato 2 repository per 2 progetti che erano così accoppiati da non avere senso separarli, quindi li abbiamo uniti.

Mostrerò come unire prima i rami master in ciascuno e poi spiegherò come estenderlo a tutti i rami che hai, spero che ti aiuti.

Se il sottomodulo funziona e si desidera convertirlo in una directory in atto, è possibile:

git clone project_uri project_name

Qui facciamo un clone pulito per funzionare. Per questo processo non è necessario inizializzare o aggiornare i sottomoduli, quindi saltalo.

cd project_name
vim .gitmodules

Modifica .gitmodulescon il tuo editor preferito (o Vim) per rimuovere il sottomodulo che intendi sostituire. Le linee che devi rimuovere dovrebbero avere un aspetto simile al seguente:

[submodule "lib/asi-http-request"]
    path = lib/asi-http-request
    url = https://github.com/pokeb/asi-http-request.git

Dopo aver salvato il file,

git rm --cached directory_of_submodule
git commit -am "Removed submodule_name as submodule"
rm -rf directory_of_submodule

Qui rimuoviamo completamente la relazione del sottomodulo in modo da poter creare portare l'altro repository sul progetto sul posto.

git remote add -f submodule_origin submodule_uri
git fetch submodel_origin/master

Qui prendiamo il repository del sottomodulo da unire.

git merge -s ours --no-commit submodule_origin/master

Qui iniziamo un'operazione di unione dei 2 repository, ma ci fermiamo prima del commit.

git read-tree --prefix=directory_of_submodule/ -u submodule_origin/master

Qui inviamo il contenuto del master nel sottomodulo alla directory in cui si trovava prima del prefisso di un nome di directory

git commit -am "submodule_name is now part of main project"

Qui completiamo la procedura eseguendo il commit delle modifiche nell'unione.

Al termine, è possibile eseguire il push e ricominciare con qualsiasi altro ramo da unire, è sufficiente controllare il ramo nel proprio repository che riceverà le modifiche e modificare il ramo che si sta portando nelle operazioni di unione e lettura.

La migliore risposta a ciò che ho trovato è qui:

http://x3ro.de/2013/09/01/Integrating-a-submodule-into-the-parent-repository.html

Questo articolo spiega molto bene la procedura.

Ecco una versione leggermente migliorata (IMHO) della risposta di @gyim. Sta facendo un mucchio di pericolose modifiche nella copia di lavoro principale, dove penso che sia molto più facile operare su cloni separati e poi unirli insieme alla fine.

In una directory separata (per rendere più semplici gli errori da ripulire e riprovare), controlla sia il repository superiore che il sottorepo.

git clone ../main_repo main.tmp
git clone ../main_repo/sub_repo sub.tmp

Prima modifica il sottorepo per spostare tutti i file nella sottodirectory desiderata

cd sub.tmp
mkdir sub_repo_path
git mv `ls | grep -v sub_repo_path` sub_repo_path/
git commit -m "Moved entire subrepo into sub_repo_path"

Prendi nota della TESTA

SUBREPO_HEAD=`git reflog | awk '{ print $1; exit; }'`

Rimuovere quindi il sottorepo dal repository principale

cd ../main.tmp
rmdir sub_repo_path
vi .gitmodules  # remove config for submodule
git add -A
git commit -m "Removed submodule sub_repo_path in preparation for merge"

E infine, uniscili

git fetch ../sub.tmp
# remove --allow-unrelated-histories if using git older than 2.9.0
git merge --allow-unrelated-histories $SUBREPO_HEAD

E fatto! In modo sicuro e senza alcuna magia.

Per quando

git rm [-r] --cached submodule_path

ritorna

fatal: pathspec 'emr/normalizers/' did not match any files

Contesto: l'ho fatto rm -r .git*nelle mie cartelle sottomodule prima di rendermi conto che dovevano essere de-sottomodificate nel progetto principale a cui le avevo appena aggiunte. Ho riscontrato l'errore sopra riportato durante la de-sottomodulazione di alcuni, ma non tutti. Ad ogni modo, li ho riparati eseguendo, (dopo, ovviamente, il rm -r .git*)

mv submodule_path submodule_path.temp
git add -A .
git commit -m "De-submodulization phase 1/2"
mv submodule_path.temp submodule_path
git add -A .
git commit -m "De-submodulization phase 2/2"

Si noti che ciò non preserva la storia.

Sulla base della risposta di VonC , ho creato un semplice script bash che lo fa. Alla addfine deve usare i caratteri jolly altrimenti annullerà il precedente rmper il sottomodulo stesso. È importante aggiungere il contenuto della directory del sottomodulo e non nominare la directory stessa nel addcomando.

In un file chiamato git-integrate-submodule:

#!/usr/bin/env bash
mv "$1" "${1}_"
git submodule deinit "$1"
git rm "$1"
mv "${1}_" "$1"
git add "$1/**"

Ho trovato più conveniente (anche?) Recuperare i dati di commit locali dal sottomodulo, perché altrimenti li perderei. (Impossibile spingerli perché non ho accesso a quel telecomando). Quindi ho aggiunto submodule / .git come remote_origin2, recuperato i commit e unito da quel ramo. Non sono sicuro se ho ancora bisogno del telecomando del sottomodulo come origine, dal momento che non ho ancora abbastanza familiarità con Git.

Ecco cosa ho trovato migliore e più semplice.

Nel repository sottomodulo, da HEAD si desidera unire il repository principale:

• git checkout -b "mergeMe"
• mkdir "foo/bar/myLib/" (percorso identico a quello in cui si desidera i file nel repository principale)
• git mv * "foo/bar/myLib/" (sposta tutto nel percorso)
• git commit -m "ready to merge into main"

Torna nel repository principale dopo aver rimosso il sottomodulo e aver cancellato il percorso "foo / bar / myLib":

• git merge --allow-unrelated-histories SubmoduleOriginRemote/mergeMe

boom fatto

storie preservate

nessun problema

Nota questo quasi identico ad alcune altre risposte. Ma questo presuppone il tuo repository sottomodulo. Inoltre, è facile ottenere future modifiche a monte per il sottomodulo.