“Git export” (“svn export” වැනි) කරනවාද?

.gitගබඩාවේ නාමාවලිය නොමැතිව ගසක පිටපතක් නිර්මාණය කරන හොඳ “git export” විසඳුමක් තිබේදැයි මම කල්පනා කළෙමි . මා දන්නා අවම වශයෙන් ක්‍රම තුනක් ඇත:

1. git cloneඉන්පසු .gitනිධිය නාමාවලිය ඉවත් කිරීමෙන් .
2. git checkout-index මෙම ක්‍රියාකාරීත්වයට ඇඟවුම් කරන නමුත් ආරම්භ වන්නේ "අපේක්ෂිත ගස දර්ශකයට කියවන්න ..." යන්නෙන් වන අතර එය කරන්නේ කෙසේදැයි මට සම්පූර්ණයෙන්ම විශ්වාස නැත.
3. git-exportතෙවන පාර්ශවීය ස්ක්‍රිප්ට් එකක් වන අතර එය අත්‍යවශ්‍යයෙන්ම git cloneතාවකාලික ස්ථානයකට rsync --exclude='.git'ගොස් අවසාන ගමනාන්තය දක්වා ගමන් කරයි.

මෙම විසඳුම් කිසිවක් ඇත්තෙන්ම සතුටුදායක යැයි මට හැඟෙන්නේ නැත. ආසන්නතම svn exportවිකල්පය 1 විකල්පය විය හැකිය, මන්ද ඒ දෙකම ඉලක්කගත නාමාවලිය පළමුව හිස් විය යුතු බැවිනි. නමුත් 2 වන විකල්පය ඊටත් වඩා හොඳ බව පෙනේ, දර්ශකයක් තුළට ගසක් කියවීම යන්නෙන් අදහස් කරන්නේ කුමක්දැයි මට සිතාගත හැකිය.

මෙය සාක්ෂාත් කර ගැනීම සඳහා සරලම ක්‍රමය විය git archiveහැකිය. ඔබට සැබවින්ම පුළුල් කළ ගසක් අවශ්‍ය නම් ඔබට මේ වගේ දෙයක් කළ හැකිය.

git archive master | tar -x -C /somewhere/else

බොහෝ විට මට git වෙතින් යමක් 'අපනයනය' කිරීමට අවශ්‍ය වන අතර, මට ඕනෑම අවස්ථාවක සම්පීඩිත ලේඛනාගාරයක් අවශ්‍ය බැවින් මම මේ වගේ දෙයක් කරමි.

git archive master | bzip2 >source-tree.tar.bz2

ZIP සංරක්ෂිතය:

git archive --format zip --output /full/path/to/zipfile.zip master 

git help archive වැඩි විස්තර සඳහා එය තරමක් නම්‍යශීලී වේ.

සංරක්ෂිතයේ .git බහලුම නොතිබුණද, කෙසේ වෙතත්, එය .gitignore, .gitattributes වැනි වෙනත් සැඟවුණු git- විශේෂිත ලිපිගොනු අඩංගු වන බව මතක තබා ගන්න. ඔබට ඒවා සංරක්ෂිතයට අවශ්‍ය නැතිනම්, ඔබ වග බලා ගන්න .gitattributes ගොනුවක අපනයන-නොසලකා හැරීමේ ගුණාංගය භාවිතා කර ඔබේ ලේඛනාගාරය කිරීමට පෙර මෙය සිදු කරන්න. වැඩිදුර කියවන්න...

සටහන: ඔබ දර්ශකය අපනයනය කිරීමට කැමති නම්, විධානය වේ

git checkout-index -a -f --prefix=/destination/path/

( වැඩි විස්තර සඳහා ග්‍රෙග්ගේ පිළිතුර බලන්න)

විකල්ප 2 යන්නෙන් අදහස් කරන්නේ කුමක්දැයි මම සොයා ගතිමි. නිධියකින් ඔබට කළ හැක්කේ:

git checkout-index -a -f --prefix=/destination/path/

මාර්ගය අවසානයේ ඇති කප්පාදුව වැදගත් වේ, එසේ නොවුවහොත් එහි ප්‍රති file ලය වනුයේ ලිපිගොනු / ගමනාන්තය තුළ 'මාර්ගය' යන උපසර්ගය සහිත වීමයි.

සාමාන්‍ය තත්වයකදී දර්ශකයේ නිධියෙහි අන්තර්ගතය අඩංගු බැවින් “අපේක්ෂිත ගස දර්ශකයට කියවීම” සඳහා විශේෂ දෙයක් කළ නොහැක. එය දැනටමත් තිබේ.

මෙම -aධජය දර්ශකයේ සියළුම ගොනු පරීක්ෂා කිරීමට (මම එය මට ඕන දේ කරන්න නොකරන බැවින්, මෙම තත්ත්වය තුළ මෙම ධජය පළමුෙවන් අදහස් කරන දේ විශ්වාස නෑ) අවශ්ය වේ. මෙම -fමෙම විධානය සාමාන්යයෙන් කරන්න නොවන ප්රතිදානය ඕනෑම දැනට පවතින ගොනු, මත ලියන්නේ ධජය හමුදා.

මෙය මා සොයන "git export" ලෙස පෙනේ.

git archive දුරස්ථ නිධිය සමඟ ද ක්‍රියා කරයි.

git archive --format=tar \
--remote=ssh://remote_server/remote_repository master | tar -xf -

Repo තුළ ඇති විශේෂිත මාර්ගය අපනයනය කිරීම සඳහා git වෙත අවසාන තර්කය ලෙස ඔබ කැමති තරම් මාර්ග එකතු කරන්න, උදා:

git archive --format=tar \
--remote=ssh://remote_server/remote_repository master path1/ path2/ | tar -xv

නිධිය GitHub හි සත්කාරකත්වය දරන්නේ නම් විශේෂ අවස්ථා පිළිතුරක්.

භාවිතා කරන්න svn export.

මා දන්නා තරමින් ගිතුබ් එයට ඉඩ නොදේ archive --remote. GitHub svn අනුකූල වන අතර ඒවාට සියලු git repos svnවෙත ප්‍රවේශ විය හැකි බැවින් svn exportඔබේ GitHub url හි යම් යම් වෙනස්කම් කිහිපයක් සමඟ සාමාන්‍යයෙන් ඔබ භාවිතා කළ හැකිය .

නිදසුනක් ලෙස සම්පූර්ණ ගබඩාවක් අපනයනය කිරීම සඳහා, trunkURL එක ප්‍රතිස්ථාපනය කරන්නේ කෙසේදැයි බලන්න master(හෝ ව්‍යාපෘතියේ HEAD ශාඛාව සකසා ඇති ඕනෑම දෙයක් ):

svn export https://github.com/username/repo-name/trunk/

ඔබට තනි ගොනුවක් හෝ යම් මාර්ගයක් හෝ ෆෝල්ඩරයක් අපනයනය කළ හැකිය:

svn export https://github.com/username/repo-name/trunk/src/lib/folder

JQuery ජාවාස්ක්‍රිප්ට් පුස්තකාලය සමඟ උදාහරණය

මෙම HEADශාඛා හෝ ස්වාමියා ශාඛා භාවිතා ලබා ගත හැකි වනු ඇත trunk:

svn ls https://github.com/jquery/jquery/trunk

HEAD අතු නොවන ඒවාට ප්‍රවේශ විය හැක්කේ /branches/:

svn ls https://github.com/jquery/jquery/branches/2.1-stable

සියලු ටැග් යටතේ /tags/එම විලාසිතා:

svn ls https://github.com/jquery/jquery/tags/2.1.3

සිට Git අත්පොත :

"සම්පූර්ණ ගසක්ම අපනයනය කිරීම" සඳහා git-checkout-index භාවිතා කිරීම

උපසර්ග හැකියාව මූලික වශයෙන් git-checkout-index "ගසක් ලෙස අපනයනය" ශ්‍රිතයක් ලෙස භාවිතා කිරීම සුළුපටු කරයි. අපේක්ෂිත ගස දර්ශකයට කියවා කරන්න:

$ git checkout-index --prefix=git-export-dir/ -a

git-checkout-indexඔබට මේ ආකාරයට භාවිතා කළ හැකි සරල එතුම මම ලියා ඇත :

git export ~/the/destination/dir

ගමනාන්තය බහලුම දැනටමත් පවතී නම්, ඔබ එකතු කිරීමට ඔබට අවශ්ය විය හැකිය -fහෝ --force.

ස්ථාපනය සරලයි; ඔබගේ කොතැනක හෝ ස්ක්‍රිප්ට් එක අතහැර දමා PATHඑය ක්‍රියාත්මක කළ හැකි බවට වග බලා ගන්න.

සඳහා ගිතුබ් ගබඩාව git-export

මෙය SVN ට වඩා Git සමඟ ඇති ගැටළුවට වඩා අඩු බව පෙනේ. Git නිධිය මූලයේ .git ෆෝල්ඩරයක් පමණක් තබන අතර SVN සෑම උප බහලුමකම .svn ෆෝල්ඩරයක් තබයි. එබැවින් "svn export" මඟින් පුනරාවර්තන විධාන රේඛා මැජික් වළක්වන අතර Git පුනරාවර්තනය සමඟ අවශ්‍ය නොවේ.

සමාන වේ

svn export . otherpath

පවතින repo එකක

git archive branchname | (cd otherpath; tar x)

සමාන වේ

svn export url otherpath

වේ

git archive --remote=url branchname | (cd otherpath; tar x)

ඔබ ගොනු බැහැර නොකරන්නේ .gitattributes export-ignoreනම් උත්සාහ කරන්නgit checkout

mkdir /path/to/checkout/
git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout -f -q

-f
දර්ශකයෙන් මාර්ග පරීක්ෂා කිරීමේදී, නොකැඩූ ප්‍රවේශයන් මත අසමත් නොවන්න; ඒ වෙනුවට, නොකැඩූ ඇතුළත් කිරීම් නොසලකා හරිනු ලැබේ.

සහ

-q වාචිකව
වළකින්න

මීට අමතරව ඔබට ඕනෑම ශාඛාවක් හෝ ටැගයක් ලබා ගත හැකිය. නැතහොත් එස්.වී.එන්. වැනි නිශ්චිත බැඳීම් සංශෝධනයකින් SHA1 එකතු කිරීම (Git හි SHA1 යනු SVN හි සංශෝධන අංකයට සමාන වේ)

mkdir /path/to/checkout/
git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout 2ef2e1f2de5f3d4f5e87df7d8 -f -q -- ./

මෙම /path/to/checkout/හිස් විය යුතුය, Git කිසිදු ගොනු ඉවත් වන්නේ නැත, නමුත් කිසිදු අනතුරු ඇඟවීමකින් තොරව ම නම ගොනු මඟින් නැවත ලියවෙනු ඇත

යාවත්කාලීන කිරීම: ටැග්, ශාඛා හෝ SHA1 සමඟ අපනයනය සඳහා පිරික්සුම භාවිතා කරන විට හිස ගසා දැමූ ගැටළුව වළක්වා ගැනීමට හෝ වැඩ කරන ගබඩාව නොවෙනස්ව තබා ගැනීමට, ඔබ -- ./අවසානයේ එකතු කළ යුතුය

මෙම ද්විත්ව ඩෑෂ් --GIT කියයි ද ඉතුරු මාර්ග ෙහෝ ගොනු පසු, ද මෙම අවස්ථාවේ දී සෑම දෙයක්ම කියනවා git checkoutවෙනස් කිරීමට නොහැකි වීමටHEAD

උදාහරණ:

මෙම විධානය පමණක් libs බහලුම ලැබෙනු ඇති අතර, ද readme.txtබව ගොනුව හරියටම සිදු

git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout fef2e1f2de5f3d4f5e87df7d8 -f -q -- ./libs ./docs/readme.txt

මෙය my_file_2_behind_HEAD.txtහිස පිටුපස කොමිස් දෙකක් නිර්මාණය කරයි (නැවත ලියයි)HEAD^2

git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout HEAD^2 -f -q -- ./my_file_2_behind_HEAD.txt

වෙනත් ශාඛාවක අපනයනය ලබා ගැනීම සඳහා

git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout myotherbranch -f -q -- ./

සිටින බව දැනුම් ./නිධිය මූල සාපේක්ෂව වේ

මම git-subodules පුළුල් ලෙස භාවිතා කරමි. මෙය මට වැඩ කරයි:

rsync -a ./FROM/ ./TO --exclude='.*'

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

• සියලුම සංශෝධන අපනයනය නොකිරීමෙන් එය දුරස්ථ ගබඩාවකට ගමනාගමනය අවම කරයි
• අපනයන නාමාවලියෙහි මෙටා තොරතුරු එයට ඇතුළත් නොවේ

• Svn භාවිතයෙන් එක්තරා ශාඛාවක් අපනයනය කිරීම සුදුසු මාර්ගයක් නියම කිරීමෙන් සිදු කෙරේ

  git clone --depth 1 --branch master git://git.somewhere destination_path
  rm -rf destination_path/.git
  

යම් නිදහස් ගොඩනැගීම විට එය උදාහරණයක් ලෙස ස්ථාවර ශාඛා පරිගණක ක්රිඩාවට සමාන ප්රයෝජනවත් වේ --branch stableහෝ --branch release/0.9.

මෙය සියලුම අන්තර්ගතයන් පිටපත් කරනු ඇත .dot ගොනු us ණ කරයි. .Git දේවල් නොමැතිව මගේ වෙබ් යෙදුමේ git repo වෙත git cloned ව්‍යාපෘති අපනයනය කිරීමට මම මෙය භාවිතා කරමි.

cp -R ./path-to-git-repo / path / to / destination /

සරල පැරණි බෑෂ් ඉතා හොඳින් ක්‍රියා කරයි :)

ක්ලෝන තරම් සරල වූ පසු .git ෆෝල්ඩරය මකන්න:

git clone url_of_your_repo path_to_export && rm -rf path_to_export/.git

GitHub භාවිතා කරන්නන් සඳහා, අපනයන URL අත්‍යවශ්‍යgit archive --remote නොවන බැවින් මෙම ක්‍රමය කෙලින්ම ක්‍රියා නොකරනු ඇත . ඔබ URL එක සඳහා GitHub ඉල්ලා සිටිය යුතුය, පසුව එම URL එක බාගන්න. එය පහසු කරයි:curl

curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | tar xzf -

මෙය දේශීය නාමාවලියක අපනයනය කළ කේතය ඔබට ලබා දෙනු ඇත. උදාහරණයක්:

$ curl -L https://api.github.com/repos/jpic/bashworks/tarball | tar xzf -
$ ls jpic-bashworks-34f4441/
break  conf  docs  hack  LICENSE  mlog  module  mpd  mtests  os  README.rst  remote  todo  vcs  vps  wepcrack

සංස්කරණය කරන්න
ඔබට කේතය නිශ්චිත, පවතින නාමාවලියකට ඇතුළත් කිරීමට අවශ්‍ය නම් (ගිතුබ් වෙතින් අහඹු ලෙස නොව):

curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | \
tar xzC /path/you/want --strip 1

ඔව්, මෙය ඔබගේ කේතය ලේඛනාගාරයට ඇතුළත් කිරීමකින් තොරව සංරක්ෂණය කිරීම සඳහා පිරිසිදු හා පිළිවෙලට ඇති විධානයක් වන අතර කිසිදු ඉතිහාසයක් ගැන කරදර නොවී එහා මෙහා යාම හොඳය.

git archive --format zip --output /full/path/to/zipfile.zip master 

මට අවශ්‍ය වන්නේ ඔබ බව පෙන්වා දීමටයි

1. ගබඩාවේ උප ෆෝල්ඩරයක් අපනයනය කිරීම (මම SVN අපනයන අංගය භාවිතා කළේ එලෙසිනි)
2. එම ෆෝල්ඩරයේ සිට විහිදුම් ගමනාන්තය දක්වා සියල්ල පිටපත් කිරීම හරි
3. ඔබ සතුව දැනටමත් සම්පූර්ණ ගබඩාවේ පිටපතක් ඇති බැවින්.

එවිට ඔබට සඳහන් කළ දේ cp foo [destination]වෙනුවට භාවිතා කළ හැකිය git-archive master foo | -x -C [destination].

ඔබට ඕනෑම කැපවීමකදී දුරස්ථ repo එකක් zip ගොනුවක් ලෙස සංරක්ෂණය කළ හැකිය.

git archive --format=zip --output=archive.zip --remote=USERNAME@HOSTNAME:PROJECTNAME.git HASHOFGITCOMMIT

Git- අපනයනය කඩිනමින් ක්‍රියාත්මක කිරීම.

මම .empty ගොනු සෑදීම සහ ඉවත් කිරීමේ ක්‍රියාවලීන් ඔවුන්ගේම ක්‍රියාකාරිත්වය මත කොටස් කර ඇති අතර ඒවා 'git-archive' ක්‍රියාත්මක කිරීමේදී නැවත භාවිතා කිරීමේ අරමුණින් (පසුව පළ කරනු ලැබේ).

ඉලක්කගත අපනයන ෆෝල්ඩරයෙන් අනවශ්‍ය ලිපිගොනු ඉවත් කිරීම සඳහා මම '.gitattributes' ගොනුව ක්‍රියාවලියට එකතු කර ඇත්තෙමි. 'Git-export' ක්‍රියාකාරීත්වය වඩාත් කාර්යක්ෂම කරන අතරම ක්‍රියාවලියට වාචිකත්වය ඇතුළත් වේ.

EMPTY_FILE = "හිස්";

function create_empty () {
## Processing path (target-dir):
    TRG_PATH="${1}";
## Component(s):
    EXCLUDE_DIR=".git";
echo -en "\nAdding '${EMPTY_FILE}' files to empty folder(s): ...";
    find ${TRG_PATH} -not -path "*/${EXCLUDE_DIR}/*" -type d -empty -exec touch {}/${EMPTY_FILE} \;
#echo "done.";
## Purging SRC/TRG_DIRs variable(s):
    unset TRG_PATH EMPTY_FILE EXCLUDE_DIR;
    return 0;
  }

declare -a GIT_EXCLUDE;
function load_exclude () {
    SRC_PATH="${1}";
    ITEMS=0; while read LINE; do
#      echo -e "Line [${ITEMS}]: '${LINE%%\ *}'";
      GIT_EXCLUDE[((ITEMS++))]=${LINE%%\ *};
    done < ${SRC_PATH}/.gitattributes;
    GIT_EXCLUDE[${ITEMS}]="${EMPTY_FILE}";
## Purging variable(s):
    unset SRC_PATH ITEMS;
    return 0;
  }

function purge_empty () {
## Processing path (Source/Target-dir):
    SRC_PATH="${1}";
    TRG_PATH="${2}";
echo -e "\nPurging Git-Specific component(s): ... ";
    find ${SRC_PATH} -type f -name ${EMPTY_FILE} -exec /bin/rm '{}' \;
    for xRULE in ${GIT_EXCLUDE[@]}; do
echo -en "    '${TRG_PATH}/{${xRULE}}' files ... ";
      find ${TRG_PATH} -type f -name "${xRULE}" -exec /bin/rm -rf '{}' \;
echo "done.'";
    done;
echo -e "done.\n"
## Purging SRC/TRG_PATHs variable(s):
    unset SRC_PATH; unset TRG_PATH;
    return 0;
  }

function git-export () {
    TRG_DIR="${1}"; SRC_DIR="${2}";
    if [ -z "${SRC_DIR}" ]; then SRC_DIR="${PWD}"; fi
    load_exclude "${SRC_DIR}";
## Dynamically added '.empty' files to the Git-Structure:
    create_empty "${SRC_DIR}";
    GIT_COMMIT="Including '${EMPTY_FILE}' files into Git-Index container."; #echo -e "\n${GIT_COMMIT}";
    git add .; git commit --quiet --all --verbose --message "${GIT_COMMIT}";
    if [ "${?}" -eq 0 ]; then echo " done."; fi
    /bin/rm -rf ${TRG_DIR} && mkdir -p "${TRG_DIR}";
echo -en "\nChecking-Out Index component(s): ... ";
    git checkout-index --prefix=${TRG_DIR}/ -q -f -a
## Reset: --mixed = reset HEAD and index:
    if [ "${?}" -eq 0 ]; then
echo "done."; echo -en "Resetting HEAD and Index: ... ";
        git reset --soft HEAD^;
        if [ "${?}" -eq 0 ]; then
echo "done.";
## Purging Git-specific components and '.empty' files from Target-Dir:
            purge_empty "${SRC_DIR}" "${TRG_DIR}"
          else echo "failed.";
        fi
## Archiving exported-content:
echo -en "Archiving Checked-Out component(s): ... ";
        if [ -f "${TRG_DIR}.tgz" ]; then /bin/rm ${TRG_DIR}.tgz; fi
        cd ${TRG_DIR} && tar -czf ${TRG_DIR}.tgz ./; cd ${SRC_DIR}
echo "done.";
## Listing *.tgz file attributes:
## Warning: Un-TAR this file to a specific directory:
        ls -al ${TRG_DIR}.tgz
      else echo "failed.";
    fi
## Purgin all references to Un-Staged File(s):
   git reset HEAD;
## Purging SRC/TRG_DIRs variable(s):
    unset SRC_DIR; unset TRG_DIR;
    echo "";
    return 0;
  }

ප්‍රතිදානය:

$ git-export /tmp/rel-1.0.0

හිස් ෆෝල්ඩර (ය) වෙත '.empty' ගොනු එකතු කිරීම: ... සිදු කර ඇත.

පරීක්ෂා කිරීමේ දර්ශක සංරචකය (ය): ... සිදු කරන ලදි.

HEAD සහ දර්ශකය නැවත සැකසීම: ... සිදු කර ඇත.

Git- විශේෂිත සංරචක (ය) පිරිසිදු කිරීම: ...

'/tmp/rel-1.0.0/==.buildpath files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==.project files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==.gitignore files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==.git files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==.gitattributes files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==*.mno files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/***~ files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==.*~ files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==*.swp files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==*.swo files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==.DS_Store files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==.settings files' ගොනු ... ඉවරයි. '

'/tmp/rel-1.0.0/==.empty files' ගොනු ... ඉවරයි. '

ඉවරයි.

පරීක්ෂා කරන ලද සංරචක (ය) සංරක්‍ෂණය කිරීම: ... සිදු කර ඇත.

-rw-r - r-- 1 පරිපාලක රෝදය 25445901 3 නොවැ 12:57 /tmp/rel-1.0.0.tgz

මම දැන් 'git archive' ක්‍රියාකාරීත්වය 'create_empty' ශ්‍රිතය සහ වෙනත් අංග භාවිතා කරන තනි ක්‍රියාවලියකට ඇතුළත් කර ඇත්තෙමි.

function git-archive () {
    PREFIX="${1}"; ## sudo mkdir -p ${PREFIX}
    REPO_PATH="`echo "${2}"|awk -F: '{print $1}'`";
    RELEASE="`echo "${2}"|awk -F: '{print $2}'`";
    USER_PATH="${PWD}";
echo "$PREFIX $REPO_PATH $RELEASE $USER_PATH";
## Dynamically added '.empty' files to the Git-Structure:
    cd "${REPO_PATH}"; populate_empty .; echo -en "\n";
#    git archive --prefix=git-1.4.0/ -o git-1.4.0.tar.gz v1.4.0
# e.g.: git-archive /var/www/htdocs /repos/domain.name/website:rel-1.0.0 --explode
    OUTPUT_FILE="${USER_PATH}/${RELEASE}.tar.gz";
    git archive --verbose --prefix=${PREFIX}/ -o ${OUTPUT_FILE} ${RELEASE}
    cd "${USER_PATH}";
    if [[ "${3}" =~ [--explode] ]]; then
      if [ -d "./${RELEASE}" ]; then /bin/rm -rf "./${RELEASE}"; fi
      mkdir -p ./${RELEASE}; tar -xzf "${OUTPUT_FILE}" -C ./${RELEASE}
    fi
## Purging SRC/TRG_DIRs variable(s):
    unset PREFIX REPO_PATH RELEASE USER_PATH OUTPUT_FILE;
    return 0;
  }

ඔබට උප මොඩියුල සමඟ වැඩ කරන යමක් අවශ්‍ය නම් මෙය අත්හදා බැලීම වටී.

සටහන:

• MASTER_DIR = ඔබගේ උප මොඩියුල සමඟ පිරික්සුම ද පරීක්ෂා කර ඇත
• DEST_DIR = මෙම අපනයනය අවසන් වන තැන
• ඔබට rsync තිබේ නම්, මම හිතන්නේ ඔබට ඊටත් වඩා අඩු බෝල කැක්කුමකින් එකම දේ කළ හැකි වනු ඇත.

උපකල්පන:

• ඔබ මෙය MASTER_DIR හි මව් නාමාවලියෙන් ධාවනය කළ යුතුය (එනම් MASTER_DIR cd වෙතින් ..)
• DEST_DIR නිර්මාණය කර ඇතැයි උපකල්පනය කෙරේ. ඔබට අවශ්‍ය නම් DEST_DIR නිර්මාණය කිරීම ඇතුළත් කිරීමට මෙය වෙනස් කිරීම පහසුය

cd MASTER_DIR && tar -zcvf ../DEST_DIR/export.tar.gz --exclude = '. git *'. && cd ../DEST_DIR/ && tar xvfz export.tar.gz && rm export.tar.gz

මගේ කැමැත්ත ඇත්තටම ඇති වනු ඇත ගාස්තු නොමැත අපනයන ඔබගේ කේතය ක බෙදාහැරිය සංරක්ෂිත (.tar.bz2, .zip, .jar, හෝ සුදුසු යමක් වේ) ඔබගේ Makefile (හෝ වෙනත් ස්ථාන ඉදි පද්ධතිය) අපේක්ෂිත ඉලක්කය. ඔබ GNU autotools හෝ Perl's MakeMaker පද්ධති භාවිතා කරන්නේ නම්, මෙය ස්වයංක්‍රීයව ඔබ වෙනුවෙන් පවතින බව මම සිතමි. එසේ නොවේ නම්, එය එක් කිරීමට මම තරයේ නිර්දේශ කරමි.

ETA (2012-09-06): වාව්, රළු පහත වැටීම්. ඔබේ ප්‍රභව කේත පාලන මෙවලමට වඩා ඔබේ බෙදාහැරීම් ඔබේ ගොඩනැඟිලි මෙවලම් සමඟ ගොඩනගා ගැනීම වඩා හොඳ යැයි මම තවමත් විශ්වාස කරමි. ගොඩනැඟීමේ මෙවලම් සමඟ පුරාවස්තු තැනීම ගැන මම විශ්වාස කරමි. මගේ වර්තමාන රැකියාවේදී, අපගේ ප්‍රධාන නිෂ්පාදනය කුහුඹුවන්ගේ ඉලක්කය සමඟ ගොඩනගා ඇත. අප සිටින්නේ ප්‍රභව කේත පාලන පද්ධති මාරු කිරීමේ මධ්‍යයේ වන අතර, මෙම කුහුඹුවන්ගේ ඉලක්කය පැවතීම යන්නෙන් අදහස් වන්නේ සංක්‍රමණයේ එක් අඩු කරදරයකි.

මෙමඟින් ලිපිගොනු පරාසයක (C සිට G) තාර ගොනුවකට පිටපත් කරනු ඇත. සටහන: මෙය ලැබෙන්නේ ලිපිගොනු පමණි. සම්පූර්ණ ගබඩාව නොවේ. මෙතැන් සිට තරමක් වෙනස් කරන ලදි

උදාහරණ ඉතිහාසය කැප කරන්න

A -> B -> C -> D -> E -> F -> G -> H -> I.

git diff-tree -r --no-commit-id --name-only --diff-filter=ACMRT C~..G | xargs tar -rf myTarFile.tar

git-diff-tree අත්පොත පිටුව

-r -> උප ගස් වලට යොමු වන්න

--no-commit-id -> git diff-tree අදාළ වන විට බැඳීම් හැඳුනුම්පත සමඟ රේඛාවක් ප්‍රතිදානය කරයි. මෙම ධජය බැඳීම් හැඳුනුම් ප්‍රතිදානය යටපත් කළේය.

--name-only -> වෙනස් කළ ගොනු වල නම් පමණක් පෙන්වන්න.

--diff-filter = ACMRT -> මෙම ගොනු පමණක් තෝරන්න. සම්පූර්ණ ගොනු ලැයිස්තුව සඳහා මෙහි බලන්න

C..G -> මෙම පරාසයේ ලිපිගොනු

C ~ -> commit C. වෙතින් ලිපිගොනු ඇතුළත් කරන්න.

| xargs tar -rf myTarFile -> තාර වෙත ප්‍රතිදාන

මම ප්‍රශ්නය තේරුම් ගත් පරිදි, එය දේශීය ගබඩාවකින් රාජ්‍යයක් උකහා ගැනීමට වඩා සේවාදායකයෙන්, ඉතිහාසයකින් තොරව සහ වෙනත් ශාඛා වල දත්ත නොමැතිව බාගත කිරීම ගැන වැඩි යමක් වේ (මෙහි බොහෝ පිළිතුරු සපයන්නන් මෙන්).

එය මේ ආකාරයෙන් කළ හැකිය:

git clone -b someBranch --depth 1 --single-branch git://somewhere.com/repo.git \
&& rm -rf repo/.git/

• --single-branch Git 1.7.10 (2012 අප්‍රේල්) සිට ලබා ගත හැකිය.
• --depth(විය?) දෝෂ සහිත බව වාර්තා වේ , නමුත් අපනයනයක දී, සඳහන් කළ කරුණු වැදගත් නොවේ.

යෙදවීමේ ස්ක්‍රිප්ටයක් සඳහා මට මෙය අවශ්‍ය වූ අතර මට ඉහත සඳහන් කිසිදු ප්‍රවේශයක් භාවිතා කළ නොහැකි විය. ඒ වෙනුවට මම වෙනස් විසඳුමක් සොයා ගතිමි:

#!/bin/sh
[ $# -eq 2 ] || echo "USAGE $0 REPOSITORY DESTINATION" && exit 1
REPOSITORY=$1
DESTINATION=$2
TMPNAME="/tmp/$(basename $REPOSITORY).$$"
git clone $REPOSITORY $TMPNAME
rm -rf $TMPNAME/.git
mkdir -p $DESTINATION
cp -r $TMPNAME/* $DESTINATION
rm -rf $TMPNAME

එය පහසුම ක්‍රමය කිරීම, මෙය .bash_profile සඳහා වන ශ්‍රිතයකි, එය වත්මන් ස්ථානයේ ලේඛනාගාරය කෙලින්ම මුදා හරිනු ඇත, පළමුව ඔබේ සුපුරුදු [url: path] වින්‍යාස කරන්න. සටහන: මෙම ශ්‍රිතය සමඟ ඔබ ක්ලෝන ක්‍රියාකාරිත්වය වළක්වා, එය දුරස්ථ repo වෙතින් කෙලින්ම ලබා ගනී.

gitss() {
    URL=[url:path]

    TMPFILE="`/bin/tempfile`"
    if [ "$1" = "" ]; then
        echo -e "Use: gitss repo [tree/commit]\n"
        return
    fi
    if [ "$2" = "" ]; then
        TREEISH="HEAD"
    else
        TREEISH="$2"
    fi
    echo "Getting $1/$TREEISH..."
    git archive --format=zip --remote=$URL/$1 $TREEISH > $TMPFILE && unzip $TMPFILE && echo -e "\nDone\n"
    rm $TMPFILE
}

.Gitconfig සඳහා අන්වර්ථය, එකම වින්‍යාසය අවශ්‍ය වේ (.git ව්‍යාපෘති තුළ විධානය ක්‍රියාත්මක කිරීම ගැන සැලකිලිමත් වන්න, එය කලින් සඳහන් කළ පරිදි සෑම විටම මූලික dir වෙතට පනිනවා , මෙය නිවැරදි වන තුරු මම පෞද්ගලිකව ශ්‍රිතයට කැමතියි

ss = !env GIT_TMPFILE="`/bin/tempfile`" sh -c 'git archive --format=zip --remote=[url:path]/$1 $2 \ > $GIT_TMPFILE && unzip $GIT_TMPFILE && rm $GIT_TMPFILE' -

මම එය කිරීමට දැක ඇති පහසුම ක්‍රමය (සහ කවුළු වලද ක්‍රියා කරයි) git bundle:

git bundle create /some/bundle/path.bundle --all

වැඩි විස්තර සඳහා මෙම පිළිතුර බලන්න: මගේ වින්ඩෝස් යන්ත්‍රයෙන් මගේ git ගබඩාව usb ඩ්‍රයිව් හරහා ලිනක්ස් යන්ත්‍රයකට පිටපත් කරන්නේ කෙසේද?

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

GIT_WORK_TREE=outputdirectory git checkout -f

ඔබ git ගබඩාවක් සහිත වෙබ් අඩවියක් කළමනාකරණය කරන්නේ නම් සහ පිරිසිදු අනුවාදයක් පරීක්ෂා කර බැලීමට කැමති නම් මෙය විශේෂයෙන් ප්‍රයෝජනවත් වේ /var/www/. මෙම අවස්ථාවෙහිදී, .git/hooks/post-receiveස්ක්‍රිප්ට් එකක මෙම විධාන එකතු කරන්න ( hooks/post-receiveහිස් ගබඩාවක, මෙම තත්වය තුළ වඩාත් සුදුසු වේ)

මම හිතන්නේ red ඇඩ්‍රිඩෙල්ගේ පෝස්ට් එක කිට්ටුමයි , නමුත් ඊට තව ටිකක් තියෙනවා - ඒ නිසා මම මෙය මෙහි එකතු කරමි; කාරණය නම්, svnඔබ repo එකක උප ෆෝල්ඩරයක සිටී නම් සහ ඔබ කරන්නේ:

/media/disk/repo_svn/subdir$ svn export . /media/disk2/repo_svn_B/subdir

පසුව svnසංශෝධනය පාලනය (ඔවුන් ද නැවුම් එකතු විය හැකි, හෝ තත්ත්වය Modified) යටතේ ඇති සියළුම ගොනු අපනයනය කරනු ඇත - ඔබ එම බහලුම තුල වෙනත් "නිසරු" නම් (මම ගණන් නෑ .svnමෙතන subfolders, නමුත් පියවි ඇසට පෙනෙන දේවල් .oගොනු) , එය අපනයනය නොකරනු ඇත; SVN repo විසින් ලියාපදිංචි කරන ලද ගොනු පමණක් අපනයනය කරනු ලැබේ. මට නම්, එක් හොඳ දෙයක් නම්, මෙම අපනයනයට තවමත් සිදු කර නොමැති දේශීය වෙනස්කම් සහිත ලිපිගොනු ඇතුළත් ය ; තවත් හොඳ දෙයක් නම්, අපනයනය කරන ලද ලිපිගොනු වල කාලරාමු මුල් ලිපිගොනු වලට සමාන වීමයි. නැතහොත්, එය svn help exportපවසන පරිදි:

2. PATH1 විසින් නිශ්චිතව දක්වා ඇති වැඩ කරන පිටපතෙන් REV සංශෝධනයෙන් පිරිසිදු ඩිරෙක්ටරි ගසක් අපනයනය කරයි. ... REV නිශ්චිතව දක්වා නොමැති නම්, සියලුම දේශීය වෙනස්කම් සුරැකෙනු ඇත. අනුවාද පාලනය යටතේ නැති ගොනු පිටපත් නොකෙරේ.

gitඑය කාලරාමුව ආරක්ෂා නොකරන බව වටහා ගැනීම සඳහා, මෙම විධානයන්හි ප්‍රතිදානය සංසන්දනය කරන්න ( gitඔබ කැමති රිපෝ එකක උප ෆෝල්ඩරයක ):

/media/disk/git_svn/subdir$ ls -la .

... සහ:

/media/disk/git_svn/subdir$ git archive --format=tar --prefix=junk/ HEAD | (tar -t -v --full-time -f -)

... සහ, කෙසේ වෙතත්, git archiveසංරක්ෂිත ගොනුවේ සියලුම කාලරාමු එක හා සමාන වීමට හේතු වන බව මම දනිමි ! git help archiveපවසයි:

කැපවීමේ හැඳුනුම්පතක් හෝ ටැග් හැඳුනුම්පතක් ලබා දෙන විට ගස හැඳුනුම්පතක් ලබා දෙන විට git සංරක්ෂිතය වෙනස් ලෙස හැසිරේ. පළමු අවස්ථාවේ දී සංරක්ෂිතයේ එක් එක් ගොනුවේ වෙනස් කිරීමේ කාලය ලෙස වත්මන් කාලය භාවිතා වේ. අවසාන අවස්ථාවෙහිදී, යොමු කරන ලද බැඳීම් වස්තුවෙහි සටහන් කර ඇති කැපවීමේ කාලය ඒ වෙනුවට භාවිතා වේ.

... නමුත් පෙනෙන ආකාරයට අවස්ථා දෙකම " එක් එක් ගොනුවේ වෙනස් කිරීමේ කාලය" නියම කරයි ; එමගින් එම ලිපිගොනු වල සත්‍ය කාලරාමු ආරක්ෂා නොකෙරේ !

එබැවින්, කාලරාමු ආරක්ෂා කර ගැනීම සඳහා, මෙහි bashපිටපතක් ඇත, එය ඇත්ත වශයෙන්ම "එක්-ලයිනර්" වේ, තරමක් සංකීර්ණ වුවත් - එබැවින් ඊට පහළින් පේළි කිහිපයකින් පළ කර ඇත:

/media/disk/git_svn/subdir$ git archive --format=tar master | (tar tf -) | (\
  DEST="/media/diskC/tmp/subdirB"; \
  CWD="$PWD"; \
  while read line; do \
    DN=$(dirname "$line"); BN=$(basename "$line"); \
    SRD="$CWD"; TGD="$DEST"; \
    if [ "$DN" != "." ]; then \
      SRD="$SRD/$DN" ; TGD="$TGD/$DN" ; \
      if [ ! -d "$TGD" ] ; then \
        CMD="mkdir \"$TGD\"; touch -r \"$SRD\" \"$TGD\""; \
        echo "$CMD"; \
        eval "$CMD"; \
      fi; \
    fi; \
    CMD="cp -a \"$SRD/$BN\" \"$TGD/\""; \
    echo "$CMD"; \
    eval "$CMD"; \
    done \
)

ඔබ "වත්මන්" නාමාවලියෙහි (ඉහළ, /media/disk/git_svn/subdir) අන්තර්ගතය අපනයනය කරන බවට උපකල්පනය කර ඇති බව සලකන්න - ඔබ අපනයනය කරන ගමනාන්තය තරමක් අපහසුතාවයට පත් කර ඇත, නමුත් එය DESTපරිසර විචල්‍යයක පවතී. මෙම පිටපත සමඟ; DESTඉහත ස්ක්‍රිප්ට් ධාවනය කිරීමට පෙර ඔබ විසින්ම ඩිරෙක්ටරිය ඔබ විසින්ම නිර්මාණය කළ යුතුය .

ස්ක්‍රිප්ට් ධාවනය වූ පසු, ඔබට සැසඳිය හැකි විය යුතුය:

ls -la /media/disk/git_svn/subdir
ls -la /media/diskC/tmp/subdirB   # DEST

... සහ එකම කාලරාමු බලන්න (අනුවාද පාලනය යටතේ තිබූ ගොනු සඳහා).

මෙය යමෙකුට උපකාරී වේ යැයි සිතමු,
චියර්ස්!

උපසර්ගයක් එක් කරන අතරතුර zip සංරක්ෂිතයකට git අපනයනය කිරීම (උදා: නාමාවලි නාමය):

git archive master --prefix=directoryWithinZip/  --format=zip -o out.zip

ඔබට උප මොඩියුලද අවශ්‍ය නම්, මෙය කළ යුත්තේ: https://github.com/meitar/git-archive-all.sh/wiki

මගේ .bashrc ගොනුවේ පහත සඳහන් උපයෝගිතා ශ්‍රිතය මා සතුව ඇත: එය වත්මන් ශාඛාවේ ලේඛනාගාරයක් git ගබඩාවක නිර්මාණය කරයි.

function garchive()
{
  if [[ "x$1" == "x-h" || "x$1" == "x" ]]; then
    cat <<EOF
Usage: garchive <archive-name>
create zip archive of the current branch into <archive-name>
EOF
  else
    local oname=$1
    set -x
    local bname=$(git branch | grep -F "*" | sed -e 's#^*##')
    git archive --format zip --output ${oname} ${bname}
    set +x
  fi
}