如何取消子模块 Git 子模块？

Question

取消子模块 Git 子模块、将所有代码带回核心存储库的最佳实践是什么？

Answer 1

如果您只想将子模块代码放入主存储库中，则只需删除子模块并将文件重新添加到主存储库中：

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 --force submodule_path  # will add files instead of commit reference
                                # --force adds files ignored by .gitignore
git commit -m "remove submodule"

如果您还想保留子模块的历史记录，您可以做一个小操作技巧：将子模块“合并”到主存储库中，这样结果将与以前相同，只是子模块文件现在位于主存储库中。

在主模块中，您需要执行以下操作：

# Create a 'marker' at the submodule commit being used
cd submodule_path
git switch --create "submodule_merge_marker"
git push --set-upstream origin submodule_merge_marker

# 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/submodule_merge_marker

# 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 --force submodule_path  # will add files instead of commit reference
                                # --force adds files ignored by .gitignore

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

生成的存储库看起来有点奇怪：将有多个初始提交。但它不会给 Git 带来任何问题。

第二种解决方案的一大优点是，您仍然可以对最初位于子模块中的文件运行 git Blame 或 git log 。事实上，这里发生的只是一个存储库中许多文件的重命名，Git 应该自动检测到这一点。如果 git log 仍然存在问题，请尝试一些选项（例如 --follow、-M、-C) 可以更好地进行重命名和复制检测。

Answer 2

我创建了一个脚本，它将子模块转换为简单的目录，同时保留所有文件历史记录。它不会遇到其他解决方案所遇到的 git log --follow 问题。这也是一个非常简单的单行调用，可以为您完成所有工作。祝你好运。

它建立在 Lucas Jenß 的出色工作之上，在他的博客文章“将子模块集成到父存储库中”，但会自动化整个过程并清理其他一些极端情况。

最新代码将在 github 上维护并修复错误，网址为 https:// github.com/jeremysears/scripts/blob/master/bin/git-submodule-rewrite，但为了正确的 stackoverflow 应答协议，我在下面包含了完整的解决方案。

用法：

$ git-submodule-rewrite <submodule-name>

git-submodule-rewrite：

#!/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

Answer 3

自 git 1.8.5（2013 年 11 月）起（不保留历史记录submodule）：

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

这将：

• 取消注册并卸载（即删除的内容）子模块（deinit，因此mv first)，
• 为您清理 .gitmodules (rm)，
• 并删除 特殊条目代表父存储库索引中的子模块SHA1（rm）。

子模块删除完成后（deinit 和 git rm），您可以将该文件夹重命名回其原始名称，并将其作为常规文件夹添加到 git 存储库中。

注意：如果子模块是由旧的 Git (< 1.8) 创建的，您可能需要删除子模块本身内嵌套的 .git 文件夹，如 评论由 Simon East

---

如果您需要保留子模块的历史记录，请参阅 jsears 的 answer，它使用 git filter-branch。

Answer 4

1. git rm --cached the_submodule_path
2. 从 .gitmodules 文件中删除子模块部分，或者如果它是唯一的子模块，则删除该文件。
3. 做一个提交“删除子模块xyz”
4. git add the_submodule_path
5. 另一个提交“添加xyz的代码库”

我还没有找到任何更简单的方法。您可以通过 git commit -a 来将 3-5 步压缩为一个步骤 - 这取决于您的喜好。

Answer 5

这里有很多答案，但所有答案似乎都过于复杂，并且可能不符合您的要求。我相信大多数人都想保留自己的历史。

对于此示例，主存储库将为[email protected]： main/main.git 和子模块存储库将是 [email 受保护]：main/child.git。这假设子模块位于父存储库的根目录中。根据需要调整说明。

首先克隆父存储库并删除旧的子模块。

git clone [email protected]:main/main.git
git submodule deinit child
git rm child
git add --all
git commit -m "remove child submodule"

现在我们将把子存储库添加到主存储库的上游。

git remote add upstream [email protected]:main/child.git
git fetch upstream
git checkout -b merge-prep upstream/master

下一步假设您想要将 merge-prep 分支上的文件移动到与上面子模块相同的位置，尽管您可以通过更改文件路径轻松更改位置。

mkdir child

将除 .git 文件夹之外的所有文件夹和文件移动到子文件夹中。

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

现在您可以简单地将文件合并回主分支。

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

在运行 git push 之前环顾四周并确保一切看起来都很好

现在你必须记住的一件事是 git log 默认情况下不会跟随移动的文件，而是通过运行 git log --follow filename 您可以查看文件的完整历史记录。

Answer 6

我们碰巧为 2 个项目创建了 2 个存储库，这两个项目耦合得非常紧密，将它们分开没有任何意义，因此我们将它们合并。

我将首先展示如何合并每个分支中的主分支，然后我将解释如何将其扩展到您获得的每个分支，希望它对您有所帮助。

如果您让子模块正常工作，并且想将其转换为适当的目录，您可以这样做：

git clone project_uri project_name

这里我们进行一个干净的克隆来工作。对于此过程，您不需要初始化或更新子模块，因此只需跳过它。

cd project_name
vim .gitmodules

使用您最喜欢的编辑器（或 Vim）编辑 .gitmodules 以删除您计划替换的子模块。您需要删除的行应如下所示：

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

保存文件后，

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

这里我们完全删除子模块关系，以便我们可以将其他存储库就地创建到项目中。

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

这里我们获取要合并的子模块存储库。

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

这里我们开始对两个存储库进行合并操作，但在提交之前停止。

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

这里，我们将子模块中 master 的内容发送到它在添加目录名前缀之前所在的目录。

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

这里，我们完成了在合并中提交更改的过程。

完成此操作后，您可以推送并重新开始与任何其他分支进行合并，只需签出存储库中将接收更改的分支并更改您在合并和读取树操作中引入的分支。

Answer 7

我找到的最佳答案在这里：

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

本文很好地解释了该过程。

Answer 8

这是 @gyim 答案的稍微改进版本（恕我直言）。他正在主工作副本中进行一系列危险的更改，我认为在单独的克隆上进行操作然后最后将它们合并在一起要容易得多。

在一个单独的目录中（为了使错误更容易清理并重试）检查顶级存储库和子存储库。

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

首先编辑子存储库以将所有文件移动到所需的子目录中

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"

记下 HEAD

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

现在从主存储库中删除子存储库

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"

最后，只需合并它们

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

就完成了！安全且没有任何魔法。

Answer 9

对于何时

git rm [-r] --cached submodule_path

返回

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

---

上下文：我在子模块文件夹中执行了 rm -r .git* ，然后意识到它们需要在我刚刚添加它们的主项目中进行子模块化。我在对某些（但不是全部）进行子模块化时遇到了上述错误。无论如何，我通过运行修复了它们（当然，在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"

请注意，这不会保留历史记录。

Answer 10

根据 VonC 的回答，我创建了一个简单的 bash 脚本来执行此操作。最后的 add 必须使用通配符，否则它将撤消子模块本身之前的 rm 。添加子模块目录的内容非常重要，而不是在add命令中命名目录本身。

在名为 git-integrate-submodule 的文件中：

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

Answer 11

在主存储库中

• git rm --cached [submodules_repo]
• git commit -m “子模块已删除。”
• git push origin [master]

在子模块 repo

• rm -rf .git

再次主 repo

• git add [submodules_repo]
• git add 。
• git commit -m“子模块存储库已添加到主模块中。”
• git push origin [主]

Answer 12

我发现（也？）从子模块获取本地提交数据更方便，因为否则我会丢失它们。 （无法推送它们，因为我无法访问该遥控器）。所以我添加了 submodule/.git 作为remote_origin2，获取它的提交并从该分支合并。
不确定我是否仍然需要子模块远程作为源，因为我对 git 还不够熟悉。

Answer 13

这是我发现的最好的&最简单。

在子模块存储库中，您想要从 HEAD 合并到主存储库中：

• git checkout -b "mergeMe"
• mkdir "foo/bar/myLib/" （与您所在的路径相同）想要主存储库上的文件）
• git mv * "foo/bar/myLib/" （全部移入路径）
• git commit -m "ready to merge into main"

返回在删除子模块并清除路径“foo/bar/myLib”后的主存储库中：

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

繁荣完成

历史记录保留

无忧

---

请注意，这几乎与某些相同其他答案。但这假设您拥有子模块存储库。此外，这还可以轻松获得子模块未来的上游更改。