සියලුම git උප මොඩියුල වලින් නවතම ඒවා ඇද ගැනීමට පහසුම ක්‍රමය

අප විසින් සංවර්ධනය කරන ලද තවත් බොහෝ පුස්තකාල මත යැපීම් ඇති විශාල ව්‍යාපෘති කිහිපයක් කළමනාකරණය කිරීමට අපි git subodules භාවිතා කරමු. සෑම පුස්තකාලයක්ම උප මොඩියුලයක් ලෙස යැපෙන ව්‍යාපෘතියට ගෙන එන වෙනම ගබඩාවකි. සංවර්ධනය අතරතුර, අපට බොහෝ විට අවශ්‍ය වන්නේ සෑම යැපෙන උප මොඩියුලයකම නවතම අනුවාදය ලබා ගැනීමට ය.

මෙය සිදු කිරීම සඳහා git සතුව බිල්ට් විධාන තිබේද? එසේ නොවේ නම්, එය කළ හැකි වින්ඩෝස් කණ්ඩායම් ගොනුවක් හෝ ඒ හා සමාන වන්නේ කෙසේද?

ඔබ ප්‍රථම වරට භාවිතා කළ යුතු රෙපෝවක් පරීක්ෂා කරන පළමු අවස්ථාව මෙය නම් --init:

git submodule update --init --recursive

1.8.2 හෝ ඊට වැඩි git--remote සඳහා, දුරස්ථ ශාඛා වල නවතම ඉඟි වෙත යාවත්කාලීන කිරීමට සහාය වීම සඳහා විකල්පය එකතු කරන ලදි:

git submodule update --recursive --remote

.gitmodulesහෝ .git/configලිපිගොනු වල නිශ්චිතව දක්වා ඇති ඕනෑම "පෙරනිමි නොවන" ශාඛාවන්ට ගරු කිරීමේ අමතර වාසියක් මෙහි ඇත (ඔබට කිසියම් දෙයක් සිදුවුවහොත් පෙරනිමිය සම්භවය / මාස්ටර් වේ, මෙහි වෙනත් පිළිතුරු සමහරක්ද ක්‍රියාත්මක වේ).

1.7.3 හෝ ඊට වැඩි git සඳහා ඔබට භාවිතා කළ හැකිය (නමුත් යාවත්කාලීනය තවමත් අදාළ වන්නේ කුමක් ද යන්න පිළිබඳ පහත දැක්වෙන කරුණු):

git submodule update --recursive

හෝ:

git pull --recurse-submodules

ඔබේ උප මොඩියුල ධාරාව වෙනුවට නවතම කොමිස් වෙත ඇද ගැනීමට ඔබට අවශ්‍ය නම්, රෙපෝ ලකුණු වෙත යොමු වන්න.

විස්තර සඳහා git-subodule (1) බලන්න

git pull --recurse-submodules --jobs=10

විශේෂාංග කට්ටලයක් මුලින් ඉගෙන ගත්තේ 1.8.5 දී ය.

දෝෂය නිවැරදි වන තුරු , පළමු වරට ඔබ ධාවනය කළ යුතුය

git subodule update --init --recursive

ආරම්භයේදී පහත විධානය ක්‍රියාත්මක වේ:

git submodule update --init --recursive

git repo නාමාවලිය තුළ සිට, මට වඩාත් සුදුසුය.

මෙය උප මොඩියුල ඇතුළු සියලුම නවතම දෑ ඇද ගනු ඇත.

පැහැදිලි කර ඇත

git - the base command to perform any git command
    submodule - Inspects, updates and manages submodules.
        update - Update the registered submodules to match what the superproject
        expects by cloning missing submodules and updating the working tree of the
        submodules. The "updating" can be done in several ways depending on command
        line options and the value of submodule.<name>.update configuration variable.
            --init without the explicit init step if you do not intend to customize
            any submodule locations.
            --recursive is specified, this command will recurse into the registered
            submodules, and update any nested submodules within.

මෙයින් පසු ඔබට ධාවනය කළ හැකිය:

git submodule update --recursive

git repo නාමාවලිය තුළ සිට, මට වඩාත් සුදුසුය.

මෙය උප මොඩියුල ඇතුළු සියලුම නවතම දෑ ඇද ගනු ඇත.

සටහන: මෙය 2009 සිට වන අතර එවකට හොඳ විය හැකි නමුත් දැන් වඩා හොඳ විකල්ප තිබේ.

අපි මෙය භාවිතා කරමු. එය හැඳින්වෙන්නේ git-pup:

#!/bin/bash
# Exists to fully update the git repo that you are sitting in...

git pull && git submodule init && git submodule update && git submodule status

සුදුසු බින් ඩිරෙක්ටරියක් තුළට දමන්න (/ usr / local / bin). වින්ඩෝස් හි තිබේ නම්, එය ක්‍රියාත්මක කිරීම සඳහා ඔබට සින්ටැක්ස් වෙනස් කිරීමට අවශ්‍ය විය හැකිය :)

යාවත්කාලීන කිරීම:

සියලුම උප මොඩියුලවල සියලුම හෙඩ් ඇද ගැනීම පිළිබඳව මුල් කතුවරයාගේ අදහස් දැක්වීමට ප්‍රතිචාර වශයෙන් - එය හොඳ ප්‍රශ්නයකි.

gitඅභ්‍යන්තරව මේ සඳහා විධානයක් නොමැති බව මට හොඳටම විශ්වාසයි . එසේ කිරීම සඳහා, උප මොඩියුලයක් සඳහා HEAD යනු කුමක්දැයි ඔබ හඳුනාගත යුතුය. එය masterවඩාත්ම යාවත්කාලීන ශාඛාව යැයි පැවසීම තරම් සරල විය හැකිය ...

මෙය අනුගමනය කිරීමෙන්, පහත දැක්වෙන දේ කරන සරල පිටපතක් සාදන්න:

1. git submodule status"නවීකරණය කරන ලද" ගබඩාවන් සඳහා පරීක්ෂා කරන්න . ප්‍රතිදාන රේඛාවල පළමු අක්‍ෂරය මෙය පෙන්නුම් කරයි. උප-රිපෝ එකක් වෙනස් කර ඇත්නම්, ඔබට ඉදිරියට යාමට අවශ්‍ය නොවනු ඇත.
2. ලැයිස්තුගත කර ඇති එක් එක් repo සඳහා, cd එහි නාමාවලියට ඇතුළු කර ධාවනය කරන්න git checkout master && git pull. දෝෂ සඳහා පරීක්ෂා කරන්න.
3. අවසානයේදී, උප මොඩියුලවල වත්මන් තත්වය දැක්වීම සඳහා පරිශීලකයාට සංදර්ශකයක් මුද්‍රණය කිරීමට මම ඔබට යෝජනා කරමි - සමහර විට සියල්ල එකතු කර කැපවීමට ඔවුන්ගෙන් ඉල්ලා සිටිනවාද?

මෙම ශෛලිය ඇත්ත වශයෙන්ම git උප මොඩියුල සඳහා නිර්මාණය කර ඇති ඒවා නොවන බව සඳහන් කිරීමට කැමැත්තෙමි. සාමාන්‍යයෙන්, ඔබට "පුස්තකාලය" "2.32" අනුවාදයේ ඇති බව පැවසීමට අවශ්‍ය වන අතර මම එය "උත්ශ්‍රේණිගත කරන්න" යැයි පවසන තුරු එලෙසම පවතිනු ඇත.

එනම්, එක් අතකින්, ඔබ විස්තර කරන ලද පිටපත සමඟ කරන්නේ කුමක්ද, නමුත් වඩා ස්වයංක්‍රීයව. රැකවරණය අවශ්‍යයි!

යාවත්කාලීන 2:

ඔබ කවුළු වේදිකාවක සිටී නම්, මෙම ප්‍රදේශවල ඉතා දක්ෂ බැවින් තිර රචනය ක්‍රියාත්මක කිරීම සඳහා පයිතන් භාවිතා කිරීම පිළිබඳව සොයා බැලීමට ඔබට අවශ්‍ය විය හැකිය. ඔබ යුනික්ස් / ලිනක්ස් හි සිටී නම්, මම යෝජනා කරන්නේ බාෂ් ස්ක්‍රිප්ට් එකක් පමණි.

පැහැදිලි කිරීම් අවශ්‍යද? අදහස් දැක්වීමක් කරන්න.

හෙන්රික් නිවැරදි මාර්ගයේ ය. 'Foreach' විධානය මඟින් ඕනෑම අත්තනෝමතික ෂෙල් ස්ක්‍රිප්ට් එකක් ක්‍රියාත්මක කළ හැකිය. නවතම දේ ඇද ගැනීමට විකල්ප දෙකක් විය හැකිය,

git submodule foreach git pull origin master

සහ,

git submodule foreach /path/to/some/cool/script.sh

එය සියලු ආරම්භක උප මොඩියුල හරහා නැවත ක්‍රියාත්මක වන අතර දී ඇති විධාන ක්‍රියාත්මක කරයි.

පහත දැක්වෙන්නේ වින්ඩෝස් හි මා වෙනුවෙන් වැඩ කිරීමයි.

git submodule init
git submodule update

සංස්කරණය කරන්න :

අදහස් දැක්වීමේදී ( ෆිල්ෆ්‍රියෝ විසින් ) නවතම අනුවාදය අවශ්‍ය බව පෙන්වා දෙන ලදී . ඒවායේ නවතම අනුවාදයේ තිබිය යුතු කැදැලි උප මොඩියුල තිබේ නම්:

git submodule foreach --recursive git pull

----- යල් පැන ගිය අදහස් පහතින් -----

මෙය කිරීමට නිල ක්‍රමය නොවේද?

git submodule update --init

මම එය සෑම විටම භාවිතා කරමි. මෙතෙක් ගැටළු නොමැත.

සංස්කරණය කරන්න:

ඔබට භාවිතා කළ හැකි බව මම සොයා ගතිමි:

git submodule foreach --recursive git submodule update --init 

එමඟින් සියලු උප මොඩියුලයන්, එනම් පරායත්තතාවයන් පුනරාවර්තනය වේ.

ඔබගේ උප මොඩියුලවල පෙරනිමි ශාඛාව එසේ නොවිය හැකි බැවින් master , මම සම්පූර්ණ Git උප මොඩියුල යාවත්කාලීන කිරීම් ස්වයංක්‍රීය කරන්නේ එලෙසයි:

git submodule init
git submodule update
git submodule foreach 'git fetch origin; git checkout $(git rev-parse --abbrev-ref HEAD); git reset --hard origin/$(git rev-parse --abbrev-ref HEAD); git submodule update --recursive; git clean -dfx'

පළමු වරට

ක්ලෝන සහ ආරම්භක උප මොඩියුලය

git clone git@github.com:speedovation/kiwi-resources.git resources
git submodule init

විවේකය

සංවර්ධනයේදී උප මොඩියුලය අදින්න සහ යාවත්කාලීන කරන්න

git pull --recurse-submodules  && git submodule update --recursive

නවතම සම්භවය සඳහා Git උප මොඩියුලය යාවත්කාලීන කරන්න

git submodule foreach git pull origin master

කැමති ක්‍රමය පහතින් විය යුතුය

git submodule update --remote --merge

සටහන: අවසාන විධාන දෙක එකම හැසිරීමක් ඇත

මෙය ක්‍රියාත්මක වන්නේ කුමන අනුවාදයේ සිටදැයි මම නොදනිමි, නමුත් ඔබ සොයන්නේ එයයි:

git submodule update --recursive

git pullමූල ගබඩාව යාවත්කාලීන කිරීම සඳහා මම එය භාවිතා කරමි :

git pull && git submodule update --recursive

ඉහත පිළිතුරු හොඳයි, කෙසේ වෙතත් අපි මෙය පහසු කිරීම සඳහා git-hooks භාවිතා කළ නමුත් එයින් පෙනෙන්නේ git 2.14 හි , ඔබ git config submodule.recurseඔබේ git ගබඩාවට අදින විට උප මොඩියුල යාවත්කාලීන කිරීමට හැකි වන පරිදි සත්‍ය ලෙස සැකසිය හැකි බවයි.

කෙසේ වෙතත්, ඔබ සතුව ඇති සියලුම උප මොඩියුලයන් ශාඛා මත තිබේ නම් ඒවා වෙනස් කිරීමේ අතුරු ආබාධයක් ඇති කරයි, නමුත් ඔබට එම හැසිරීම අවශ්‍ය නම් දැනටමත් මෙම කාර්යය කළ හැකිය.

භාවිතා කිරීමෙන් කළ හැකිය:

git config submodule.recurse true

කවුළු සඳහා Git 2.6.3 :

git submodule update --rebase --remote

Repo හි ඉහළ මට්ටමේ සිට:

git submodule foreach git checkout develop
git submodule foreach git pull

මෙය සියලු ශාඛා නවීනතම සංවර්ධනයට හා ඇද ගැනීමට මාරු කරනු ඇත

මම ආරාධනා කළා මේ අනුගත විසින් gahooa ගේ ඉහත පිළිතුර :

එය git සමඟ ඒකාබද්ධ කරන්න [alias]...

ඔබේ මව් ව්‍යාපෘතියට මෙවැනි දෙයක් තිබේ නම් .gitmodules:

[submodule "opt/submodules/solarized"]
    path = opt/submodules/solarized
    url = git@github.com:altercation/solarized.git
[submodule "opt/submodules/intellij-colors-solarized"]
    path = opt/submodules/intellij-colors-solarized
    url = git@github.com:jkaving/intellij-colors-solarized.git

ඔබේ .gitconfig තුළ මේ වගේ දෙයක් එකතු කරන්න

[alias]
    updatesubs = "!sh -c \"git submodule init && git submodule update && git submodule status\" "

ඔබේ උප මොඩියුල යාවත්කාලීන කිරීමට, ධාවනය කරන්න:

git updatesubs

මගේ පරිසර සැකසුම් ගබඩාවේ ඒ පිළිබඳ උදාහරණයක් මා සතුව ඇත .

ඔබ දැන් කළ යුත්තේ සරල දෙයකි git checkout

මෙම ගෝලීය වින්‍යාසය හරහා එය සක්‍රීය කිරීමට වග බලා ගන්න: git config --global submodule.recurse true

ඔබගේ සියලු git ගබඩාවල උප මොඩියුල තිබුණත් නැතත් අදින්න විධාන රේඛාව මෙන්න:

ROOT=$(git rev-parse --show-toplevel 2> /dev/null)
find "$ROOT" -name .git -type d -execdir git pull -v ';'

ඔබ ඔබේ ඉහළ GIT නිධිය තුල එය ධාවනය නම්, ඔබ විස්ථාපනය කල හැකි "$ROOT"බවට ..

මෙය සිදු කිරීම සඳහා ඔබට පිටපතක් ලිවීමට සිදුවේ යැයි මම සිතමි. ඇත්තම කිව්වොත්, මම එය සිදු කිරීම සඳහා පයිතන් ස්ථාපනය කළ හැකි අතර එවිට ඔබට සෑම නාමාවලියකටම භාවිතා os.walkකර cdසුදුසු විධාන නිකුත් කළ හැකිය. කණ්ඩායම හැරුණු විට පයිතන් හෝ වෙනත් ස්ක්‍රිප්ටින් භාෂාවක් භාවිතා කිරීම මඟින් ස්ක්‍රිප්ට් වෙනස් කිරීමකින් තොරව උප ව්‍යාපෘති පහසුවෙන් එකතු කිරීමට / ඉවත් කිරීමට ඔබට ඉඩ සලසයි.

සටහන: එතරම් පහසු ක්‍රමයක් නොව, වැඩ කළ හැකි අතර එයට එයටම ආවේණික වූ වාසි ඇත.

යමෙකුට ක්ලෝන කිරීමට අවශ්‍ය වන්නේ HEADනිධියක සංශෝධනයක් පමණක් HEADවන අතර එහි සියලුම උප මොඩියුලවල (එනම් "කඳ" පරීක්ෂා කිරීම සඳහා) පමණි, එවිට යමෙකුට පහත දැක්වෙන ලුආ ස්ක්‍රිප්ට් භාවිතා කළ හැකිය . සමහර විට සරල විධානය මඟින් git submodule update --init --recursive --remote --no-fetch --depth=1සොයාගත නොහැකි gitදෝෂයක් ඇතිවිය හැකිය. මෙම අවස්ථාවේදී යමෙකුට විධානය .git/modulesභාවිතා කරමින් ඩිරෙක්ටරියේ උප බහලුම සහ ක්ලෝන උප මොඩියුලය අතින් පිරිසිදු කළ යුතුය git clone --separate-git-dir. එකම සංකීර්ණතාව වන්නේ සුපිරි ප්‍රොජෙක්ට් ගසෙහි URL , උප .gitමොඩියුලයේ නාමාවලිය සහ උප මොඩියුලයේ මාර්ගය සොයා ගැනීමයි .

සටහන: ස්ක්‍රිප්ට් පරීක්‍ෂා කරනු ලබන්නේ https://github.com/boostorg/boost.gitගබඩාවට එරෙහිව පමණි . එහි සුවිශේෂතා: සියලුම උප මොඩියුලයන් එකම ධාරකයක සත්කාරක වන අතර .gitmodulesඑහි අඩංගු වන්නේ සාපේක්ෂ URL ය.

-- mkdir boost ; cd boost ; lua ../git-submodules-clone-HEAD.lua https://github.com/boostorg/boost.git .
local module_url = arg[1] or 'https://github.com/boostorg/boost.git'
local module = arg[2] or module_url:match('.+/([_%d%a]+)%.git')
local branch = arg[3] or 'master'
function execute(command)
    print('# ' .. command)
    return os.execute(command)
end
-- execute('rm -rf ' .. module)
if not execute('git clone --single-branch --branch master --depth=1 ' .. module_url .. ' ' .. module) then
    io.stderr:write('can\'t clone repository from ' .. module_url .. ' to ' .. module .. '\n')
    return 1
end
-- cd $module ; git submodule update --init --recursive --remote --no-fetch --depth=1
execute('mkdir -p ' .. module .. '/.git/modules')
assert(io.input(module .. '/.gitmodules'))
local lines = {}
for line in io.lines() do
    table.insert(lines, line)
end
local submodule
local path
local submodule_url
for _, line in ipairs(lines) do
    local submodule_ = line:match('^%[submodule %"([_%d%a]-)%"%]$')
    if submodule_ then
        submodule = submodule_
        path = nil
        submodule_url = nil
    else
        local path_ = line:match('^%s*path = (.+)$')
        if path_ then
            path = path_
        else
            submodule_url = line:match('^%s*url = (.+)$')
        end
        if submodule and path and submodule_url then
            -- execute('rm -rf ' .. path)
            local git_dir = module .. '/.git/modules/' .. path:match('^.-/(.+)$')
            -- execute('rm -rf ' .. git_dir)
            execute('mkdir -p $(dirname "' .. git_dir .. '")')
            if not execute('git clone --depth=1 --single-branch --branch=' .. branch .. ' --separate-git-dir ' .. git_dir .. ' ' .. module_url .. '/' .. submodule_url .. ' ' .. module .. '/' .. path) then
                io.stderr:write('can\'t clone submodule ' .. submodule .. '\n')
                return 1
            end
            path = nil
            submodule_url = nil
        end
    end
end