Làm thế nào để tôi loại bỏ một mô hình con Git?

Nhân tiện, có lý do gì tôi không thể làm git submodule rm whatever?

Kể từ git1.8.3 (ngày 22 tháng 4 năm 2013) :

Không có cách nào để nói "Tôi không còn hứng thú với mô hình con này nữa", một khi bạn thể hiện sự quan tâm của mình đối với mô hình con với " submodule init".
" submodule deinit" Là cách để làm như vậy.

Quá trình xóa cũng sử dụng git rm(kể từ git1.8.5 tháng 10 năm 2013).

Tóm lược

Quá trình loại bỏ 3 bước sau đó sẽ là:

0. mv a/submodule a/submodule_tmp

1. git submodule deinit -f -- a/submodule    
2. rm -rf .git/modules/a/submodule
3. git rm -f a/submodule
# Note: a/submodule (no trailing slash)

# or, if you want to leave it in your working tree and have done step 0
3.   git rm --cached a/submodule
3bis mv a/submodule_tmp a/submodule

Giải trình

rm -rf: Điều này được đề cập trong câu trả lời của Daniel Schroeder và được Eonil tóm tắt trong các bình luận :

Lá này .git/modules/<path-to-submodule>/không thay đổi.
Vì vậy, nếu bạn một lần xóa một mô hình con với phương thức này và thêm lại chúng một lần nữa, điều đó sẽ không thể thực hiện được vì kho lưu trữ đã bị hỏng.

git rm: Xem cam kết 95c16418 :

Hiện tại, việc sử dụng " git rm" trên một mô hình con sẽ loại bỏ cây công việc của mô hình con khỏi siêu dự án và gitlink khỏi chỉ mục.
Nhưng phần của mô hình con trong phần .gitmodulescòn lại chưa được xử lý, phần còn lại của mô hình con đã bị loại bỏ và có thể gây khó chịu cho người dùng (trái ngược với cài đặt trong .git/config, điều này phải được nhắc nhở rằng người dùng đã thể hiện sự quan tâm đến mô hình con này để nó được lặp lại sau khi một cam kết cũ hơn được kiểm tra).

Hãy " git rm" giúp người dùng bằng cách không chỉ loại bỏ mô hình con khỏi cây công việc mà còn loại bỏ phần " submodule.<submodule name>" khỏi .gitmodulestệp và giai đoạn cả hai.

git submodule deinit: Nó bắt nguồn từ bản vá này :

Với " git submodule init" người dùng có thể nói với git rằng họ quan tâm đến một hoặc nhiều mô hình con và muốn nó được điền vào cuộc gọi tiếp theo tới " git submodule update".
Nhưng hiện tại không có cách nào dễ dàng để họ có thể nói với git rằng họ không quan tâm đến một mô hình con nữa và muốn thoát khỏi cây công việc cục bộ (trừ khi người dùng biết nhiều về nội bộ mô đun con và loại bỏ submodule.$name.urlcài đặt "" khỏi .git/configcùng với công việc cây mình).

Giúp những người dùng đó bằng cách cung cấp deinitlệnh ''.
Điều này loại bỏ toàn bộ submodule.<name>phần từ .git/configmột trong các mô hình con đã cho (hoặc cho tất cả những phần đã được khởi tạo nếu ' .' được đưa ra).
Thất bại nếu cây công việc hiện tại chứa các sửa đổi trừ khi bị ép buộc.
Khiếu nại khi có một mô hình con được cung cấp trên dòng lệnh, không thể tìm thấy cài đặt url .git/config, nhưng dù sao cũng không thất bại.

Điều này quan tâm nếu các bước khởi tạo (de) ( .git/configvà .git/modules/xxx)

Kể từ git1.8.5, cũnggit rm cần phải quan tâm đến:

• ' add' Bước ghi lại url của một submodule trong .gitmodulesfile: nó là cần phải loại bỏ cho bạn.
• mục đặc biệt của mô hình con (như được minh họa bởi câu hỏi này ): git rm xóa nó khỏi chỉ mục:
  git rm --cached path_to_submodule(không có dấu gạch chéo)
  Điều đó sẽ xóa thư mục đó được lưu trữ trong chỉ mục với chế độ đặc biệt "160000", đánh dấu nó là thư mục gốc mô đun con .

Nếu bạn quên bước cuối cùng đó và cố gắng thêm một mô hình con như một thư mục thông thường, bạn sẽ nhận được thông báo lỗi như:

git add mysubmodule/file.txt 
Path 'mysubmodule/file.txt' is in submodule 'mysubmodule'

Lưu ý: kể từ Git 2.17 (quý 2 năm 2018), ginit subodule deinit không còn là tập lệnh shell.
Đó là một cuộc gọi đến một chức năng C.

Xem cam kết 2e61273 , cam kết 1342476 (14 tháng 1 năm 2018) của Prathamesh Chavan ( pratham-pc) .
^{(Được hợp nhất bởi Junio ​​C Hamano - gitster- trong cam kết ead8dbe , ngày 13 tháng 2 năm 2018)}

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper deinit \
  ${GIT_QUIET:+--quiet} \
  ${prefix:+--prefix "$prefix"} \
  ${force:+--force} \
  ${deinit_all:+--all} "$@"

Qua trang Hướng dẫn mô hình con Git :

Để loại bỏ một mô hình con, bạn cần phải:

1. Xóa phần có liên quan từ .gitmodulestập tin.
2. Giai đoạn .gitmodulesthay đổi:
   git add .gitmodules
3. Xóa phần có liên quan từ .git/config.
4. Xóa các tệp mô hình con khỏi cây làm việc và chỉ mục:
   git rm --cached path_to_submodule(không có dấu gạch chéo).
5. Xóa .gitthư mục của mô hình con :
   rm -rf .git/modules/path_to_submodule
6. Cam kết thay đổi:
   git commit -m "Removed submodule <name>"
7. Xóa các tệp mô hình con hiện tại chưa được đóng gói:
   rm -rf path_to_submodule

Xem thêm : các bước thay thế dưới đây .

Chỉ cần một lưu ý. Kể từ git 1.8.5.2, hai lệnh sẽ thực hiện:

git rm the_submodule
rm -rf .git/modules/the_submodule

Như câu trả lời của @Mark Cheverton đã chỉ ra một cách chính xác, nếu dòng thứ hai không được sử dụng, ngay cả khi bạn đã loại bỏ mô hình con bây giờ, thư mục .git / mô-đun / the_submodule còn lại sẽ ngăn không cho mô hình con tương tự trở lại hoặc thay thế trong tương lai . Ngoài ra, như @VonC đã đề cập, git rmsẽ thực hiện hầu hết các công việc trên một mô hình con.

--Cập nhật (07/5/2017) -

Chỉ cần làm rõ, the_submodulelà đường dẫn tương đối của mô hình con bên trong dự án. Ví dụ, đó là subdir/my_submodulenếu mô hình con nằm trong thư mục con subdir.

Như đã chỉ ra một cách chính xác trong các bình luận và các câu trả lời khác , hai lệnh (mặc dù đủ chức năng để loại bỏ một mô hình con), không để lại dấu vết trong [submodule "the_submodule"]phần .git/config(kể từ tháng 7 năm 2017), có thể được loại bỏ bằng lệnh thứ ba:

git config -f .git/config --remove-section submodule.the_submodule 2> /dev/null

Phần lớn các câu trả lời cho câu hỏi này đã lỗi thời, không đầy đủ hoặc phức tạp không cần thiết.

Một mô hình con được nhân bản bằng git 1.7.8 hoặc mới hơn sẽ để lại nhiều nhất bốn dấu vết của chính nó trong repo cục bộ của bạn. Quá trình loại bỏ bốn dấu vết đó được đưa ra bởi ba lệnh dưới đây:

# Remove the submodule entry from .git/config
git submodule deinit -f path/to/submodule

# Remove the submodule directory from the superproject's .git/modules directory
rm -rf .git/modules/path/to/submodule

# Remove the entry in .gitmodules and remove the submodule directory located at path/to/submodule
git rm -f path/to/submodule

Các bước đơn giản

1. Xóa các mục cấu hình:
   git config -f .git/config --remove-section submodule.$submodulename
git config -f .gitmodules --remove-section submodule.$submodulename
2. Xóa thư mục khỏi chỉ mục:
   git rm --cached $submodulepath
3. Cam kết
4. Xóa các tệp không sử dụng:
   rm -rf $submodulepath
rm -rf .git/modules/$submodulename

Xin lưu ý: $submodulepath không chứa dấu gạch chéo hàng đầu hoặc dấu.

Lý lịch

Khi bạn làm git submodule add, nó chỉ thêm nó vào .gitmodules, nhưng một khi bạn đã làm git submodule init, nó được thêm vào .git/config.

Vì vậy, nếu bạn muốn loại bỏ các mô-đun, nhưng có thể khôi phục nó một cách nhanh chóng, thì hãy làm điều này:

git rm --cached $submodulepath
git config -f .git/config --remove-section submodule.$submodulepath

Đó là một ý tưởng tốt để làm git rebase HEADđầu tiên và git commit cuối cùng, nếu bạn đặt điều này trong một kịch bản.

Ngoài ra, hãy xem câu trả lời cho Tôi có thể hủy bỏ mô hình con Git không? .

Ngoài các khuyến nghị, tôi cũng phải rm -Rf .git/modules/path/to/submodulecó thể thêm một mô hình con mới có cùng tên (trong trường hợp của tôi, tôi đã thay thế một ngã ba bằng bản gốc)

Để loại bỏ một mô hình con được thêm vào bằng cách sử dụng:

git submodule add blah@blah.com:repos/blah.git lib/blah

Chạy:

git rm lib/blah

Đó là nó.

Đối với các phiên bản cũ của git (khoảng ~ 1,8,5), hãy sử dụng:

git submodule deinit lib/blah
git rm lib/blah
git config -f .gitmodules --remove-section submodule.lib/blah

Bạn phải xóa mục trong .gitmodulesvà .git/configvà xóa thư mục của mô-đun khỏi lịch sử:

git rm --cached path/to/submodule

Nếu bạn sẽ viết trên danh sách gửi thư của git, có lẽ ai đó sẽ thực hiện một kịch bản shell cho bạn.

Bạn có thể sử dụng bí danh để tự động hóa các giải pháp do người khác cung cấp:

[alias]
  rms = "!f(){ git rm --cached \"$1\";rm -r \"$1\";git config -f .gitmodules --remove-section \"submodule.$1\";git config -f .git/config --remove-section \"submodule.$1\";git add .gitmodules; }; f"

Đặt nó trong cấu hình git của bạn, và sau đó bạn có thể làm: git rms path/to/submodule

Tóm lại, đây là những gì bạn nên làm:

1. Đặt path_to_submodulevar (không có dấu gạch chéo):

   path_to_submodule=path/to/submodule

2. Xóa dòng liên quan khỏi tệp .gitmodules:

   git config -f .gitmodules --remove-section submodule.$path_to_submodule

3. Xóa phần có liên quan khỏi .git / config

   git config -f .git/config --remove-section submodule.$path_to_submodule

4. Hủy bỏ và chỉ xóa $ path_to_submodule khỏi chỉ mục (để tránh mất thông tin)

   git rm --cached $path_to_submodule

5. Theo dõi các thay đổi được thực hiện cho .gitmodules

   git add .gitmodules

6. Cam kết siêu dự án

   git commit -m "Remove submodule submodule_name"

7. Xóa các tập tin mô hình con chưa được đóng gói

   rm -rf $path_to_submodule

   rm -rf .git/modules/$path_to_submodule

Nếu mô hình con vô tình được thêm vào vì bạn đã thêm, đã cam kết và đẩy một thư mục đã là kho lưu trữ Git (có chứa .git), bạn sẽ không có .gitmodulestệp để chỉnh sửa hoặc bất cứ thứ gì trong đó .git/config. Trong trường hợp này, tất cả những gì bạn cần là:

git rm --cached subfolder
git add subfolder
git commit -m "Enter message here"
git push

FWIW , tôi cũng đã xóa .gitthư mục trước khi thực hiện git add.

Tôi thấy deinitcông việc tốt cho tôi:

git submodule deinit <submodule-name>    
git rm <submodule-name>

Từ tài liệu git :

deinit

Hủy đăng ký các mô hình con đã cho, tức là xóa toàn bộ submodule.$name phần khỏi .git / config cùng với cây công việc của chúng.

Sau khi thử nghiệm tất cả các câu trả lời khác nhau trên trang web này, tôi đã kết thúc với giải pháp này:

#!/bin/sh
path="$1"
if [ ! -f "$path/.git" ]; then
  echo "$path is no valid git submodule"
  exit 1
fi
git submodule deinit -f $path &&
git rm --cached $path &&
rm -rf .git/modules/$path &&
rm -rf $path &&
git reset HEAD .gitmodules &&
git config -f .gitmodules --remove-section submodule.$path

Điều này khôi phục chính xác trạng thái như trước khi bạn thêm mô hình con. Bạn có thể ngay lập tức thêm mô hình con một lần nữa, điều này là không thể với hầu hết các câu trả lời ở đây.

git submodule add $giturl test
aboveScript test

Điều này để lại cho bạn một kiểm tra sạch sẽ không có thay đổi để cam kết.

Điều này đã được thử nghiệm với:

$ git --version
git version 1.9.3 (Apple Git-50)

Những gì tôi đang làm tháng 12 năm 2012 (kết hợp hầu hết các câu trả lời này):

oldPath="vendor/example"
git config -f .git/config --remove-section "submodule.${oldPath}"
git config -f .gitmodules --remove-section "submodule.${oldPath}"
git rm --cached "${oldPath}"
rm -rf "${oldPath}"              ## remove src (optional)
rm -rf ".git/modules/${oldPath}" ## cleanup gitdir (optional housekeeping)
git add .gitmodules
git commit -m "Removed ${oldPath}"

Đây là những gì tôi đã làm:

1.) Xóa phần có liên quan khỏi tệp .gitmodules. Bạn có thể sử dụng lệnh dưới đây:

git config -f .gitmodules --remove-section "submodule.submodule_name"

2.) Giai đoạn .gitmodulesthay đổi

git add .gitmodules

3.) Xóa phần có liên quan từ .git/config. Bạn có thể sử dụng lệnh dưới đây:

git submodule deinit -f "submodule_name"

4.) Xóa gitlink (không có dấu gạch chéo):

git rm --cached path_to_submodule

5.) Dọn dẹp .git/modules:

rm -rf .git/modules/path_to_submodule

6.) Cam kết:

git commit -m "Removed submodule <name>"

7.) Xóa các tập tin mô hình con chưa được theo dõi

rm -rf path_to_submodule

Gần đây tôi phát hiện ra một dự án git bao gồm nhiều lệnh liên quan đến git hữu ích: https://github.com/visionmedia/git-extras

Cài đặt nó và gõ:

git-delete-submodule submodule

Sau đó mọi việc đã xong. Thư mục mô hình con sẽ bị xóa khỏi repo của bạn và vẫn tồn tại trong hệ thống tập tin của bạn. Sau đó, bạn có thể cam kết thay đổi như : git commit -am "Remove the submodule".

Tôi đã phải thực hiện các bước của John Douthat một bước nữa và cdvào thư mục của mô hình con, và sau đó xóa kho Git:

cd submodule
rm -fr .git

Sau đó, tôi có thể cam kết các tệp như là một phần của kho Git gốc mà không cần tham chiếu cũ đến một mô hình con.

Dưới đây là 4 bước mà tôi thấy cần thiết hoặc hữu ích (những bước quan trọng trước tiên):

git rm -f the_submodule
rm -rf .git/modules/the_submodule
git config -f .git/config --remove-section submodule.the_submodule
git commit -m "..."

Về lý thuyết , git rmở bước 1 nên chăm sóc nó. Hy vọng rằng, phần thứ hai của câu hỏi OP có thể được trả lời tích cực vào một ngày nào đó (rằng điều này có thể được thực hiện trong một lệnh).

Nhưng kể từ tháng 7 năm 2017, bước 2 là cần thiết để xóa dữ liệu .git/modules/nếu không, bạn không thể thêm mô hình con trở lại trong tương lai.

Bạn có thể có thể thoát khỏi hai bước trên cho git 1.8.5+ như câu trả lời của tinlyx đã lưu ý, vì tất cả git submodulecác lệnh dường như hoạt động.

Bước 3 loại bỏ phần cho the_submoduletrong tập tin .git/config. Điều này nên được thực hiện cho đầy đủ. (Mục nhập có thể gây ra sự cố cho các phiên bản git cũ hơn, nhưng tôi không có bài kiểm tra nào).

Đối với điều này, hầu hết các câu trả lời đề nghị sử dụng git submodule deinit. Tôi thấy nó rõ ràng hơn và ít gây nhầm lẫn khi sử dụng git config -f .git/config --remove-section. Theo tài liệu git-subodule , git deinit:

Hủy đăng ký các mô hình con đã cho ... Nếu bạn thực sự muốn xóa một mô hình con khỏi kho lưu trữ và cam kết sử dụng git-rm [1] thay vào đó .

Cuối cùng nhưng không kém phần quan trọng, nếu bạn không git commit, bạn sẽ / có thể gặp lỗi khi thực hiện git submodule summary(kể từ git 2.7):

fatal: Not a git repository: 'the_submodule/.git'
* the_submodule 73f0d1d...0000000:

Điều này là bất kể bạn làm bước 2 hay 3.

project dir:     ~/foo_project/
submodule:       ~/foo_project/lib/asubmodule
- - - - - - - - - - - - - - - - - - - - - - - - -
run:
  1.   cd ~/foo_project
  2.   git rm lib/asubmodule && 
          rm .git/modules/lib/asubmodule && 
            git submodule lib/asubmodule deinit --recursive --force

Tôi chỉ tìm thấy tập tin ẩn .submodule (quên tên chính xác), nó có một danh sách ... bạn có thể xóa chúng theo cách đó. Tôi chỉ có một, vì vậy tôi đã xóa nó. Đơn giản, nhưng nó có thể gây rối cho Git, vì tôi không biết liệu có bất cứ thứ gì được gắn vào mô hình con không. Có vẻ ổn cho đến nay, ngoài vấn đề nâng cấp thông thường của libetpan, nhưng điều đó (hy vọng) không liên quan.

Thông báo không ai đăng thủ công xóa, vì vậy thêm

Với git 2.17 trở lên, nó chỉ là:

git submodule deinit -f {module_name}
git add {module_name}
git commit

Nếu bạn vừa thêm mô hình con, và ví dụ, bạn chỉ cần thêm mô hình con sai hoặc bạn thêm nó vào vị trí sai, chỉ cần làm git stashsau đó xóa thư mục. Điều này giả định rằng việc thêm mô hình con là điều duy nhất bạn đã làm trong repo gần đây.

Vì lợi ích của người đọc, điều này ở đây cố gắng tóm tắt và đưa ra hướng dẫn từng bước về cách thực hiện nếu mọi thứ không hoạt động như mong đợi. Sau đây là cách được thử nghiệm và an toàn cho gitphiên bản 2.17trở lên để thoát khỏi mô hình con :

submodule="path/to/sub"              # no trailing slash!
git submodule deinit -- "$submodule"
git rm -- "$submodule"

• Nếu điều này không làm việc cho bạn, xem bên dưới.
• Không có lựa chọn. Không có gì nguy hiểm. Và thậm chí không xem xét làm nhiều hơn nữa!
• Đã thử nghiệm với Debian Buster 2.20.1và Ubuntu 18.04 2.17.1.
• "$submodule" chỉ để nhấn mạnh nơi đặt tên, và bạn phải cẩn thận với không gian và những thứ tương tự
• Nếu trên Windows bỏ qua dòng đầu tiên và thay thế "$submodule"bằng cách Windows của một đường dẫn được chỉ định đúng đến mô hình con. (Tôi không phải Windows)

Cảnh báo!

Không bao giờ chạm vào bên trong của .gitthư mục chính mình! Chỉnh sửa bên trong .gitbước vào mặt tối. Tránh xa bằng mọi giá!

Và vâng, bạn có thể đổ lỗi gitcho điều này, vì nhiều thứ tiện dụng đã bị thiếu trong gitquá khứ. Giống như một cách thích hợp để loại bỏ các mô đun con một lần nữa.

Tôi nghĩ rằng có một phần rất nguy hiểm trong tài liệu của git submodule. Nó khuyên bạn nên loại bỏ $GIT_DIR/modules/<name>/chính mình. Theo hiểu biết của tôi, điều này không chỉ sai, nó còn cực kỳ nguy hiểm và gây ra những cơn đau đầu lớn trong tương lai! Xem bên dưới.

Lưu ý rằng

git module deinit

là nghịch đảo trực tiếp với

git module init

nhưng

git submodule deinit -- module
git rm -- module

cũng khá nghịch đảo

git submodule add -- URL module
git submodule update --init --recursive -- module

bởi vì một số lệnh về cơ bản cần phải làm nhiều hơn là một điều duy nhất:

• git submodule deinit -- module
  • (1) cập nhật .git/config
• git rm
  • (2) loại bỏ các tập tin của mô-đun
  • (3) do đó loại bỏ đệ quy các mô hình con của mô hình con
  • (4) cập nhật .gitmodules
• git submodule add
  • kéo dữ liệu đến .git/modules/NAME/
  • (1) có git submodule init, vì vậy cập nhật.git/config
  • (2) git submodule update, do đó, kiểm tra mô-đun một cách không hồi quy
  • (4) cập nhật .gitmodules
• git submodule update --init --recursive -- module
  • kéo thêm dữ liệu nếu cần
  • (3) kiểm tra các mô hình con của mô hình con đệ quy

Điều này không thể đối xứng hoàn toàn, vì việc giữ nó đối xứng nghiêm ngặt không có nhiều ý nghĩa. Đơn giản là không cần nhiều hơn hai lệnh. Ngoài ra, "lấy dữ liệu" là ẩn, vì bạn cần nó, nhưng việc xóa thông tin được lưu trong bộ nhớ cache không được thực hiện, vì điều này hoàn toàn không cần thiết và có thể xóa sạch dữ liệu quý giá.

Điều này thực sự gây hoang mang cho người mới, nhưng về cơ bản là một điều tốt: gitchỉ cần làm điều rõ ràng và làm điều đó đúng, và thậm chí không cố gắng làm nhiều hơn nữa. gitlà một công cụ, phải thực hiện một công việc đáng tin cậy, thay vì chỉ là một "Eierlegende Wollmilchsau" ("Eierlegende Wollmilchsau" dịch cho tôi thành "phiên bản xấu xa của con dao quân đội Thụy Sĩ").

Vì vậy, tôi hiểu những lời phàn nàn của mọi người, nói rằng "Tại sao tôi không làm điều githiển nhiên cho tôi". Điều này là do "rõ ràng" ở đây phụ thuộc vào quan điểm. Độ tin cậy trong mỗi tình huống là quan trọng hơn nhiều. Do đó những gì rõ ràng đối với bạn thường không phải là điều đúng đắn trong tất cả các tình huống kỹ thuật có thể. Xin nhớ rằng: AFAICS gitđi theo con đường kỹ thuật, không phải xã hội. (Do đó tên thông minh: git)

Nếu thất bại

Các lệnh trên có thể thất bại do sau:

• Bạn gitquá già Sau đó sử dụng một cái mới hơn git. (Xem bên dưới cách.)
• Bạn có dữ liệu không được cam kết và có thể mất dữ liệu. Sau đó, tốt hơn cam kết chúng đầu tiên.
• Subodule của bạn không sạch sẽ trong một git cleaný nghĩa. Sau đó, đầu tiên làm sạch mô hình con của bạn bằng cách sử dụng lệnh đó. (Xem bên dưới.)
• Bạn đã làm một cái gì đó trong quá khứ không được hỗ trợ bởi git . Sau đó, bạn đang ở trong bóng tối và mọi thứ trở nên xấu xí và phức tạp. (Có lẽ sử dụng máy khác để sửa nó.)
• Có lẽ có nhiều cách để thất bại mà tôi không biết (tôi chỉ là một số gitngười sử dụng năng lượng.)

Sửa lỗi có thể làm theo.

Sử dụng cái mới hơn git

Nếu máy tính của bạn quá cũ không có submodule deinittrong bạn git. Nếu bạn không muốn (hoặc có thể) cập nhật git, thì chỉ cần sử dụng máy khác với máy mới hơn git! gitcó nghĩa là được phân phối đầy đủ, vì vậy bạn có thể sử dụng cái khác gitđể hoàn thành công việc:

• workhorse:~/path/to/worktree$ git status --porcelain không được xuất bất cứ thứ gì! Nếu có, hãy dọn dẹp mọi thứ trước!
• workhorse:~/path/to/worktree$ ssh account@othermachine
• othermachine:~$ git clone --recursive me@workhorse path/to/worktree/.git TMPWORK && cd TMPWORK
• Bây giờ làm các công cụ con
• othermachine:~/TMPWORK$ git commit . -m . && exit
• workhorse:~/path/to/worktree$ git fetch account@othermachine:TMPWORK/.git
• workhorse:~/path/to/worktree$ git merge --ff-only FETCH_HEAD. Nếu điều này không làm việc, sử dụnggit reset --soft FETCH_HEAD
• Bây giờ dọn dẹp mọi thứ, cho đến khi git statussạch sẽ trở lại. Bạn có thể làm như vậy, bởi vì bạn đã có nó sạch sẽ, nhờ bước đầu tiên.

Đây othermachinecó thể là một số VM hoặc một số Ubuntu WSL trong Windows, bất cứ điều gì. Ngay cả một chroot(nhưng tôi cho rằng bạn không phải là root, bởi vì nếu bạn là rootnó sẽ dễ dàng hơn để cập nhật lên bản mới hơn git).

Lưu ý rằng nếu bạn không thể sshvào, có rất nhiều cách để vận chuyển gitkho. Bạn có thể sao chép worktree của mình trên một số thanh USB (bao gồm cả .gitthư mục) và sao chép từ thanh này. Sao chép bản sao, chỉ để có được mọi thứ một cách sạch sẽ một lần nữa. Đây có thể là PITA, trong trường hợp các mô đun con của bạn không thể truy cập trực tiếp từ othermachine. Nhưng cũng có một giải pháp cho việc này:

git config --add url.NEWURLPREFIX.insteadOf ORIGINALURLPREFIX

Bạn có thể sử dụng bội số này, và điều này được lưu vào $HOME/.gitconfig. Cái gì đó như

git config --add 'url./mnt/usb/repo/.insteadof' https://github.com/

viết lại các URL như

https://github.com/XXX/YYY.git

vào

/mnt/usb/repo/XXX/YYY.git

Thật dễ dàng nếu bạn bắt đầu làm quen với gitcác tính năng mạnh mẽ như thế này.

Dọn dẹp đồ đạc trước

Làm sạch bằng tay là tốt, bởi vì cách này có lẽ bạn phát hiện ra một số điều bạn quên mất.

• Nếu git phàn nàn về những thứ chưa được lưu, hãy cam kết và đẩy nó vào nơi an toàn.
• Nếu git phàn nàn về một số thức ăn thừa, git statusvà git clean -ixfdlà bạn của bạn
• Cố gắng kiêng những lựa chọn rmvà deinitmiễn là bạn có thể. Tùy chọn (như -f) gitlà tốt nếu bạn là Pro. Nhưng khi bạn đến đây, có lẽ bạn không có nhiều kinh nghiệm trong submodulekhu vực. Vì vậy, tốt hơn là an toàn hơn xin lỗi.

Thí dụ:

$ git status --porcelain
 M two
$ git submodule deinit two
error: the following file has local modifications:
    two
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'two' contains local modifications; use '-f' to discard them
$ cd two
$ git submodule deinit --all
error: the following file has local modifications:
    md5chk
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'md5chk' contains local modifications; use '-f' to discard them
$ cd md5chk
$ git submodule deinit --all
error: the following file has local modifications:
    tino
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'tino' contains local modifications; use '-f' to discard them
$ cd tino
$ git status --porcelain
?? NEW
$ git clean -i -f -d
Would remove the following item:
  NEW
*** Commands ***
    1: clean                2: filter by pattern    3: select by numbers    4: ask each
    5: quit                 6: help
What now> 1
Removing NEW
$ cd ../../..
$ git status --porcelain
$ git submodule deinit two
Cleared directory 'two'
Submodule 'someunusedname' (https://github.com/hilbix/src.git) unregistered for path 'two'

Bạn thấy, không -fcần thiết trên submodule deinit. Nếu mọi thứ sạch sẽ, theo một git cleannghĩa nào đó. Cũng lưu ý rằng git clean -xkhông cần thiết. Điều này có nghĩa là git submodule deinitloại bỏ vô điều kiện các tập tin không bị theo dõi bị bỏ qua. Đây thường là những gì bạn muốn, nhưng đừng quên nó. Đôi khi các tệp bị bỏ qua có thể là quý giá, như dữ liệu được lưu trong bộ nhớ cache mất hàng giờ đến hàng ngày để được tính lại.

Tại sao không bao giờ loại bỏ $GIT_DIR/modules/<name>/?

Có lẽ mọi người muốn loại bỏ kho lưu trữ được lưu trữ, bởi vì họ sợ gặp phải một vấn đề sau này. Điều này là đúng, nhưng chạy vào "vấn đề" đó là cách chính xác để giải quyết nó! Bởi vì việc khắc phục rất dễ dàng và được thực hiện ngay bạn sẽ có thể sống hạnh phúc mãi mãi. Điều này tránh được rắc rối rườm rà hơn so với khi bạn tự xóa dữ liệu.

Thí dụ:

mkdir tmptest &&
cd tmptest &&
git init &&
git submodule add https://github.com/hilbix/empty.git two &&
git commit -m . &&
git submodule deinit two &&
git rm two &&
git commit -m . &&
git submodule add https://github.com/hilbix/src.git two

Dòng cuối cùng xuất ra lỗi sau:

A git directory for 'two' is found locally with remote(s):
  origin    https://github.com/hilbix/empty.git
If you want to reuse this local git directory instead of cloning again from
  https://github.com/hilbix/src.git
use the '--force' option. If the local git directory is not the correct repo
or you are unsure what this means choose another name with the '--name' option.

Tại sao lỗi này? Bởi vì .git/modules/two/trước đây đã được điền từ https://github.com/hilbix/empty.git và bây giờ sẽ được nhập lại từ một thứ khác, cụ thể là https://github.com/hilbix/src.git . Bạn sẽ không thấy điều này nếu bạn nhập lại từ https://github.com/hilbix/empty.git

Làm gì bây giờ? Vâng, chỉ cần làm chính xác như đã nói! Sử dụng--name someunusedname

git submodule add --name someunusedname https://github.com/hilbix/src.git two

.gitmodules sau đó trông giống như

[submodule "someunusedname"]
    path = two
    url = https://github.com/hilbix/src.git

ls -1p .git/modules/ cho

someunusedname/
two/

Bằng cách này trong tương lai, bạn có thể chuyển nhánh / cam kết tiến và lùi và sẽ không bao giờ gặp rắc rối nữa , do two/có hai kho lưu trữ ngược dòng khác nhau (và có thể không tương thích). Và tốt nhất là: Bạn cũng giữ cả hai bộ nhớ cache cục bộ.

• Điều này không chỉ đúng với bạn. Nó cũng đúng cho tất cả những người khác sử dụng kho lưu trữ của bạn.
• Và bạn không mất lịch sử. Trong trường hợp bạn quên đẩy phiên bản mới nhất của mô hình con cũ, bạn có thể nhập bản sao cục bộ và thực hiện sau đó. Lưu ý rằng điều khá phổ biến là ai đó quên đẩy một số mô hình con (vì đây là Pita cho người mới, cho đến khi họ quen với việc này git).

Tuy nhiên, nếu bạn xóa thư mục được lưu trong bộ nhớ cache, cả hai thanh toán khác nhau sẽ vấp ngã nhau, vì bạn sẽ không sử dụng các --nametùy chọn, phải không? Vì vậy, mỗi lần bạn thực hiện kiểm tra, có lẽ bạn phải xóa .git/modules/<module>/thư mục nhiều lần. Điều này là vô cùng cồng kềnh và làm cho nó khó sử dụng một cái gì đó như git bisect.

Vì vậy, có một lý do rất kỹ thuật để giữ thư mục mô-đun này là một giữ chỗ. Những người khuyên nên xóa một cái gì đó bên dưới .git/modules/hoặc không biết rõ hơn hoặc quên nói với bạn rằng điều này làm cho các tính năng mạnh mẽ git bisectgần như không thể sử dụng nếu điều này vượt qua sự không tương thích của mô hình con như vậy.

Một lý do nữa được hiển thị ở trên. Nhìn vào ls. Bạn thấy gì ở đó?

Vâng, biến thể thứ 2 của mô-đun two/không nằm dưới .git/modules/two/, nó nằm dưới .git/modules/someunusedname/! Vì vậy, những điều như git rm $module; rm -f .git/module/$modulelà hoàn toàn sai! Bạn phải tham khảo ý kiến module/.githoặc .gitmodulestìm ra thứ phù hợp để loại bỏ!

Vì vậy, không chỉ hầu hết các câu trả lời khác rơi vào cái bẫy nguy hiểm này, ngay cả các gittiện ích mở rộng rất phổ biến cũng có lỗi này ( hiện đã được sửa ở đó )! Vì vậy, tốt hơn hãy giữ tay của .git/thư mục nếu bạn không chính xác, những gì bạn đang làm!

Và từ quan điểm triết học, xóa sổ lịch sử luôn là sai! Ngoại trừ cơ học lượng tử , như thường lệ, nhưng đây là một thứ hoàn toàn khác.

FYI bạn có thể đoán nó: hilbix là tài khoản GitHub của tôi.

Tóm lại, đây là những gì bạn nên làm:

Đặt var_to_submodule var (không có dấu gạch chéo):

path_to_submodule=path/to/submodule

Xóa dòng liên quan khỏi tệp .gitmodules:

git config -f .gitmodules --remove-section submodule.$path_to_submodule

Xóa phần có liên quan khỏi .git / config

git config -f .git/config --remove-section submodule.$path_to_submodule

Hủy bỏ và chỉ xóa $ path_to_submodule khỏi chỉ mục (để tránh mất thông tin)

git rm --cached $path_to_submodule

Theo dõi các thay đổi được thực hiện cho .gitmodules

git add .gitmodules

Cam kết siêu dự án

git commit -m "Remove submodule submodule_name"

Xóa các tập tin mô hình con chưa được đóng gói

rm -rf $path_to_submodule

rm -rf .git/modules/$path_to_submodule

Xem thêm: Dòng hướng dẫn thay thế

Đó là dễ dàng:

1. Xóa phần khỏi .gitmodules
2. Gọi: git add .gitmodules
3. Gọi: git submodule deinit <path to submodule>
4. Gọi: git rm <path to submodule>
5. Cam kết và đẩy

Bạn sẽ phải xóa các tệp mô-đun trên dự án của bạn bằng tay.

Tôi đã tạo một tập lệnh bash để giảm bớt quá trình loại bỏ. Nó cũng kiểm tra xem có thay đổi nào trong repo không lưu và yêu cầu xác nhận hay không. Nó đã được thử nghiệm trên os xsẽ rất thú vị để biết nếu nó hoạt động như trên các bản phân phối linux phổ biến:

https://gist.github.com/fabifrank/cdc7e67fd194333760b060835ac0172f

Trong git mới nhất, chỉ cần 4 thao tác để loại bỏ mô đun con git.

• Xóa mục tương ứng trong .gitmodules
• Thay đổi giai đoạn git add .gitmodules
• Xóa thư mục mô hình con git rm --cached <path_to_submodule>
• Cam kết nó git commit -m "Removed submodule xxx"

Trong trường hợp bạn cần thực hiện nó trong một dòng lệnh với bash script như dưới đây:

$ cd /path/to/your/repo && /bin/bash $HOME/remove_submodule.sh /path/to/the/submodule

Tạo tập tin bash script trong $HOMEthư mục có tên là remove_submodule.sh:

#!/bin/bash

git config -f .gitmodules --remove-section submodule.$1
git config -f .git/config --remove-section submodule.$1
git rm --cached $1
git add .gitmodules
git commit -m "Remove submodule in $1"
rm -rf $1
rm -rf .git/modules/$1
git push origin $(git rev-parse --abbrev-ref HEAD) --force --quiet

• Một mô hình con có thể bị xóa bằng cách chạy git rm <submodule path> && git commit. Điều này có thể được hoàn tác bằng cách sử dụng git revert.
  • Việc xóa sẽ xóa dữ liệu theo dõi của siêu dự án, cả mục nhập gitlink và phần trong .gitmodulestệp.
  • Thư mục làm việc của mô hình con được xóa khỏi hệ thống tệp, nhưng thư mục Git được giữ xung quanh vì nó có thể kiểm tra các cam kết trong quá khứ mà không yêu cầu tìm nạp từ kho lưu trữ khác.
• Để loại bỏ hoàn toàn một mô hình con, ngoài ra hãy xóa thủ công$GIT_DIR/modules/<name>/ .

Nguồn: git help submodules

Loại bỏ mô đun con git

Để loại bỏ một gitmô hình con dưới 4 bước là cần thiết.

1. Loại bỏ các mục tương ứng trong .gitmodulestập tin. Mục nhập có thể được đề cập dưới đây

[submodule "path_to_submodule"]
    path = path_to_submodule
    url = url_path_to_submodule

2. Thay đổi giai đoạn git add .gitmodules
3. Loại bỏ thư mục mô hình con git rm --cached <path_to_submodule>.
4. Cam kết git commit -m "Removed submodule xxx"và đẩy.

Cần thêm 2 bước được đề cập dưới đây để làm sạch hoàn toàn mô hình con trong bản sao nhân bản cục bộ.

5. Loại bỏ các mục tương ứng trong .git/configtập tin. Mục nhập có thể được đề cập dưới đây

[submodule "path_to_submodule"]
    url = url_path_to_submodule

6. Làm rm -rf .git/modules/path_to_submodule

Các bước thứ 5 và 6 này không tạo ra bất kỳ thay đổi nào cần cam kết.