git एक "गिट निर्यात" करें(जैसे "svn export")?




git-archive svn-export (24)

हां, this संग्रह में किसी भी गिट समावेशन के बिना आपके कोड को संग्रहीत करने के लिए एक साफ और साफ आदेश है और किसी भी गिट प्रतिबद्ध इतिहास के बारे में चिंता किए बिना पास होने के लिए अच्छा है।

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

मैं सोच रहा हूं कि कोई अच्छा "गिट निर्यात" समाधान है जो .git रिपोजिटरी निर्देशिका के बिना पेड़ की एक प्रति बनाता है। कम से कम तीन विधियों के बारे में मुझे पता है:

  1. git clone बाद .git रिपोजिटरी निर्देशिका को हटाकर।
  2. git checkout-index इस कार्यक्षमता को दर्शाता है लेकिन "इंडेक्स में वांछित पेड़ को बस पढ़ें ..." से शुरू होता है, जिसे मैं पूरी तरह से सुनिश्चित नहीं करता कि कैसे करना है।
  3. git-export एक तीसरी पार्टी स्क्रिप्ट है जो अनिवार्य रूप से एक अस्थायी स्थान पर एक git clone करता है जिसके बाद अंतिम गंतव्य में rsync --exclude='.git' होता है।

इनमें से कोई भी समाधान वास्तव में मुझे संतोषजनक होने के रूप में नहीं रोकता है। svn export निकटतम विकल्प विकल्प 1 हो सकता है, क्योंकि उन दोनों को लक्ष्य निर्देशिका को खाली होने की आवश्यकता होती है। लेकिन विकल्प 2 भी बेहतर लगता है, मानते हुए कि मैं यह समझ सकता हूं कि इंडेक्स में पेड़ को पढ़ने का क्या अर्थ है।


मुझे इसे एक तैनाती स्क्रिप्ट के लिए जरूरी था और मैं उपर्युक्त दृष्टिकोणों में से किसी का भी उपयोग नहीं कर सका। इसके बजाय मैंने एक अलग समाधान निकाला:

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

मैंने इसे करने के लिए सबसे आसान तरीका देखा है (और विंडोज़ पर भी काम करता है) है git bundle:

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

अधिक जानकारी के लिए यह उत्तर देखें: मैं अपने विंडोज मशीन से यूएसबी ड्राइव के माध्यम से एक लिनक्स मशीन में अपनी गिट रिपॉजिटरी कैसे कॉपी कर सकता हूं?


मैंने git-checkout-index चारों ओर एक साधारण रैपर लिखा है जिसे आप इस तरह उपयोग कर सकते हैं:

git export ~/the/destination/dir

यदि गंतव्य निर्देशिका पहले से मौजूद है, तो आपको -f या --force जोड़ने की आवश्यकता होगी।

स्थापना सरल है; बस अपने PATH में कहीं भी स्क्रिप्ट ड्रॉप करें, और सुनिश्चित करें कि यह निष्पादन योग्य है।

git-export लिए जिथब भंडार


संभवतः इसे प्राप्त करने का सबसे आसान तरीका git archive साथ है। यदि आपको वास्तव में केवल विस्तारित पेड़ की आवश्यकता है तो आप ऐसा कुछ कर सकते हैं।

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

अधिकांश समय मुझे गिट से कुछ 'निर्यात' करने की ज़रूरत है, मैं किसी भी मामले में संपीड़ित संग्रह चाहता हूं इसलिए मैं ऐसा कुछ करता हूं।

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

ज़िप संग्रह:

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

अधिक जानकारी के लिए git help archive , यह काफी लचीला है।

ध्यान रखें कि संग्रह में .git निर्देशिका नहीं होगी, हालांकि, इसमें अन्य छिपी गिट-विशिष्ट फ़ाइलें शामिल होंगी जैसे कि .gitignore, .gitattributes, आदि। यदि आप उन्हें संग्रह में नहीं चाहते हैं, तो सुनिश्चित करें कि आप एक .gitattributes फ़ाइल में निर्यात-अनदेखा विशेषता का उपयोग करें और अपना संग्रह करने से पहले इसे प्रतिबद्ध करें। और पढो...

नोट: यदि आप इंडेक्स को निर्यात करने में रुचि रखते हैं, तो आदेश है

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

(अधिक जानकारी के लिए ग्रेग का जवाब देखें)


के बराबर

svn export . otherpath

एक मौजूदा रेपो के अंदर है

git archive branchname | (cd otherpath; tar x)

के बराबर

svn export url otherpath

है

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

मेरी प्राथमिकता वास्तव में आपके मेकफ़ाइल (या अन्य निर्माण प्रणाली) में एक दूरस्थ लक्ष्य होना चाहिए जो आपके कोड (.tar.bz2, .zip, .jar, या जो कुछ भी उचित है) का एक वितरित संग्रह निर्यात करता है। यदि आप जीएनयू ऑटोोटूल या पर्ल की मेकमेकर सिस्टम का उपयोग करते हैं, तो मुझे लगता है कि यह आपके लिए स्वचालित रूप से मौजूद है। यदि नहीं, तो मैं इसे जोड़ने की अत्यधिक अनुशंसा करता हूं।

ईटीए (2012-09-06): वाह, कठोर downvotes। मुझे अभी भी विश्वास है कि आपके स्रोत कोड नियंत्रण उपकरण की बजाय अपने निर्माण टूल के साथ अपने वितरण का निर्माण करना बेहतर है। मैं निर्माण उपकरण के साथ कलाकृतियों के निर्माण में विश्वास करता हूं। मेरे वर्तमान काम में, हमारा मुख्य उत्पाद एक चींटी लक्ष्य के साथ बनाया गया है। हम स्रोत कोड नियंत्रण प्रणाली स्विच करने के बीच में हैं, और इस चींटी लक्ष्य की उपस्थिति का मतलब माइग्रेशन में एक कम परेशानी है।


एक विशेष मामला जवाब अगर गिटहब पर भंडार होस्ट किया गया है।

बस svn export उपयोग करें।

जहां तक ​​मुझे पता है कि archive --remote अनुमति नहीं देता है। यद्यपि गिटहब एसवीएन संगत है और उनके पास सभी गिट रिपोज़ svn सुलभ हैं, इसलिए आप केवल अपने गिटहब यूआरएल में कुछ समायोजन के साथ svn export उपयोग कर सकते हैं।

उदाहरण के लिए एक संपूर्ण भंडार निर्यात करने के लिए, ध्यान दें कि यूआरएल में trunk master को प्रतिस्थापित master (या जो भी परियोजना की हेड शाखा सेट है ):

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

और आप एक फ़ाइल या यहां तक ​​कि एक निश्चित पथ या फ़ोल्डर निर्यात कर सकते हैं:

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

JQuery जावास्क्रिप्ट लाइब्रेरी के साथ उदाहरण

HEAD का उपयोग करके HEAD शाखा या मास्टर शाखा उपलब्ध होगी:

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

इसे आसान तरीका करना, यह .bash_profile के लिए एक फ़ंक्शन है, यह सीधे वर्तमान स्थान पर संग्रह को अनजिप करता है, पहले अपना सामान्य [url: path] कॉन्फ़िगर करें। नोट: इस फ़ंक्शन के साथ आप क्लोन ऑपरेशन से बचते हैं, यह सीधे रिमोट रेपो से मिलता है।

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 प्रोजेक्ट्स के अंदर कमांड को निष्पादित करने के लिए सावधानी बरतें, यह हमेशा यहां बताए गए आधार डीआईआर पर कूदता है , जब तक कि यह तय नहीं हो जाता है, मैं व्यक्तिगत रूप से फ़ंक्शन को प्राथमिकता देता हूं

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' -

मैं गिट-सबोड्यूल का व्यापक रूप से उपयोग करता हूं। यह मेरे लिए काम करता है:

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

यह सभी सामग्री की प्रतिलिपि बनायेगा, .dot फ़ाइलों को घटाएं। मैं गिट क्लोन परियोजनाओं को अपने वेब ऐप के गिट रेपो में .git सामान के बिना निर्यात करने के लिए इसका उपयोग करता हूं।

सीपी-आर ./path-to-git-repo / पथ / से / गंतव्य /

सादा पुराना बैश बस महान काम करता है :)


विकल्प 1 बहुत कुशल नहीं लगता है। क्या होगा यदि क्लोन करने के लिए क्लाइंट में कोई जगह नहीं है और फिर.git फ़ोल्डर को हटा दें ?

आज मैंने खुद को ऐसा करने की कोशिश की, जहां ग्राहक रास्पबेरी पीआई है जिसमें लगभग कोई जगह नहीं छोड़ी गई है। इसके अलावा, मैं भंडार से कुछ भारी फ़ोल्डर को भी बाहर करना चाहता हूं।

विकल्प 2 और अन्य उत्तर यहां इस परिदृश्य में मदद नहीं करते हैं। न तो git archive(क्योंकि .gitattributesफ़ाइल को करने की आवश्यकता है , और मैं इस बहिष्करण को भंडार में सहेजना नहीं चाहता)।

यहां मैं अपना समाधान साझा करता हूं, विकल्प 3 के समान, लेकिन इसकी आवश्यकता के बिना git clone:

tmp=`mktemp`
git ls-tree --name-only -r HEAD > $tmp
rsync -avz --files-from=$tmp --exclude='fonts/*' . raspberry:

rsyncसंपीड़न के लिए समतुल्य रेखा के लिए रेखा को बदलना भी git archiveएक तरह के बहिष्करण विकल्प के साथ काम करेगा (जैसा कि here पूछा गया here )।


ऐसा लगता है कि एसवीएन की तुलना में गिट के साथ यह एक मुद्दा है। गिट केवल एक .git फ़ोल्डर को भंडार रूट में रखता है, जबकि एसवीएन प्रत्येक उपनिर्देशिका में एक .svn फ़ोल्डर डालता है। तो "svn export" रिकर्सिव कमांड लाइन जादू से बचाता है, जबकि गिट रिकर्सन के साथ आवश्यक नहीं है।


गिट मैनुअल से :

"पूरे पेड़ को निर्यात करने" के लिए गिट-चेकआउट-इंडेक्स का उपयोग करना

उपसर्ग क्षमता मूल रूप से गिट-चेकआउट-इंडेक्स को "पेड़ के रूप में निर्यात" फ़ंक्शन के रूप में उपयोग करने के लिए तुच्छ बनाता है। इंडेक्स में वांछित पेड़ को पढ़ें, और करें:

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


आप ज़िप फ़ाइल के रूप में किसी भी प्रतिबद्धता पर रिमोट रेपो को संग्रहीत कर सकते हैं।

git archive --format=zip --output=archive.zip [email protected]:PROJECTNAME.git HASHOFGITCOMMIT

क्लोन के रूप में सरल के रूप में .git फ़ोल्डर को हटा दें:

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


गिट-निर्यात के बैश-कार्यान्वयन।

मैंने 'गिट-आर्काइव' कार्यान्वयन में उन्हें फिर से उपयोग करने के उद्देश्य से, अपने स्वयं के फ़ंक्शन पर .empty फ़ाइल निर्माण और निष्कासन प्रक्रियाओं को विभाजित किया है (बाद में पोस्ट किया जाएगा)।

लक्ष्य निर्यात फ़ोल्डर से अन-वांछित फ़ाइलों को निकालने के लिए मैंने प्रक्रिया में '.gitattributes' फ़ाइल भी शामिल की है। 'गिट-निर्यात' फ़ंक्शन को अधिक कुशल बनाते समय प्रक्रिया में शामिल शब्दशः।

"। खाली" 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' फ़ाइलों को जोड़ना: ... किया गया।

चेक-आउट इंडेक्स घटक: ... किया गया।

हेड और इंडेक्स रीसेट करना: ... किया गया।

पिटिंग गिट-विशिष्ट घटक: ...

'/tmp/rel-1.0.0/{.buildpath}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{.project}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{.gitignore}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{.git}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{.gitattributes}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{*.mno}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{*~}' फाइलें ... हो गईं। '

'/tmp/rel-1.0.0/{.*~}' फाइलें ... हो गईं। '

'/tmp/rel-1.0.0/{*.swp}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{*.swo}' फाइलें ... हो गईं। '

'/tmp/rel-1.0.0/{.DS_Store}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{.settings}' फ़ाइलें ... किया गया। '

'/tmp/rel-1.0.0/{.empty}' फाइलें ... हो गईं। '

किया हुआ।

संग्रहित चेक-आउट घटक: ... किया गया।

-आरडब्ल्यू-आर - आर-- 1 व्यवस्थापक व्हील 25445 9 01 3 नवंबर 12:57 /tmp/rel-1.0.0.tgz

मैंने अब 'गिट आर्काइव' कार्यक्षमता को एक ही प्रक्रिया में शामिल किया है जो '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;
  }

जैसा कि मैं प्रश्न को समझता हूं, यह एक स्थानीय भंडार से राज्य निकालने के बजाय, इतिहास के बिना, सर्वर के बिना, और अन्य शाखाओं के डेटा के बिना, बस कुछ निश्चित राज्यों को डाउनलोड करने के बारे में अधिक है (जैसा कि यहां कई व्यवस्थापक हैं)।

ऐसा किया जा सकता है:

git clone -b someBranch --depth 1 --single-branch git://somewhere.com/repo.git \
&& rm -rf repo/.git/
  • --single-branch गिट 1.7.10 (अप्रैल 2012) के बाद उपलब्ध है।
  • --depthक्या (था?) reportedly दोषपूर्ण है, लेकिन निर्यात के मामले में, उल्लिखित मुद्दों से कोई फर्क नहीं पड़ता।

मैं बस यह इंगित करना चाहता हूं कि आप जिस मामले में हैं

  1. भंडार के उप फ़ोल्डर को निर्यात करना (इस प्रकार मैं एसवीएन निर्यात सुविधा का उपयोग करता था)
  2. उस फ़ोल्डर से सब कुछ को तैनाती गंतव्य पर कॉपी करने के साथ ठीक है
  3. और चूंकि आपके पास पहले से ही संपूर्ण भंडार की एक प्रति है।

फिर आप उल्लिखित git-archive master foo | -x -C [destination] बजाय cp foo [destination] उपयोग कर सकते हैं git-archive master foo | -x -C [destination]


यदि आप कुछ ऐसा चाहते हैं जो सबमिड्यूल के साथ काम करता है तो यह एक लायक हो सकता है।

ध्यान दें:

  • MASTER_DIR = आपके submodules के साथ एक चेकआउट भी चेक आउट किया गया
  • DEST_DIR = जहां यह निर्यात समाप्त हो जाएगा
  • यदि आपके पास rsync है, तो मुझे लगता है कि आप भी कम गेंद दर्द के साथ एक ही चीज़ करने में सक्षम होंगे।

मान्यताओं:

  • आपको इसे MASTER_DIR की मूल निर्देशिका से चलाने की आवश्यकता है (यानी MASTER_DIR सीडी ..)
  • माना जाता है कि DEST_DIR बनाया गया है। यदि आप चाहते हैं तो एक DEST_DIR के निर्माण को शामिल करने के लिए संशोधित करना बहुत आसान है

सीडी MASTER_DIR और& tar -zcvf ../DEST_DIR/export.tar.gz --exclude = '। git *'। && cd ../DEST_DIR/ && tar xvfz export.tar.gz && rm export.tar.gz


git archive रिमोट रिपोजिटरी के साथ भी काम करता है।

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

रेपो के अंदर विशेष पथ को निर्यात करने के लिए जितना संभव हो उतना पथ जोड़ें जितना आप गिट के अंतिम तर्क के रूप में चाहते हैं, उदाहरण के लिए:

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


git archive --remote उपयोगकर्ताओं के लिए, git archive --remote विधि सीधे काम नहीं करेगा, क्योंकि docs । आपको यूआरएल के लिए गिटहब से पूछना चाहिए, फिर उस यूआरएल को डाउनलोड करें। 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

मुझे लगता है कि @Aredridel की पोस्ट निकटतम थी, लेकिन इसके लिए थोड़ा और कुछ है - इसलिए मैं इसे यहां @Aredridel ; बात यह है कि svn, यदि आप रेपो के सबफ़ोल्डर में हैं, और आप करते हैं:

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

फिर svnसंशोधन फ़ाइलों के तहत सभी फ़ाइलों को निर्यात करेगा (वे ताजा जोड़ा गया हो सकता है; या संशोधित स्थिति) - और यदि आपके पास उस निर्देशिका में अन्य "जंक" है (और मैं .svnयहां उपफोल्डर्स की गणना नहीं कर रहा हूं , लेकिन .oफाइलों जैसी दृश्यमान सामग्री ) , इसे निर्यात नहीं किया जाएगा; एसवीएन रेपो द्वारा पंजीकृत केवल उन फाइलों को निर्यात किया जाएगा। मेरे लिए, एक अच्छी बात यह है कि इस निर्यात का भी स्थानीय परिवर्तन है कि है के साथ फ़ाइलें शामिल है नहीं अभी तक किया गया; और एक और अच्छी बात यह है कि निर्यात की गई फ़ाइलों की टाइमस्टैम्प मूल के समान ही हैं। या, जैसा svn help exportकि इसे रखता है:

  1. पीएटीएच 1 द्वारा निर्दिष्ट कार्य प्रतिलिपि से एक स्वच्छ निर्देशिका पेड़ का निर्यात करता है, यदि इसे दिया जाता है तो संशोधन आरईवी पर, अन्यथा काम पर, PATH2 में। ... यदि आरईवी निर्दिष्ट नहीं है, तो सभी स्थानीय परिवर्तन संरक्षित किए जाएंगे। संस्करण नियंत्रण के तहत नहीं फ़ाइलें कॉपी नहीं की जाएगी।

यह समझने के लिए कि 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कहते हैं:

गिट आर्काइव अलग-अलग व्यवहार करता है जब एक स्वाद आईडी या टैग आईडी दिए जाने पर एक वृक्ष आईडी बनाम दिया जाता है। पहले मामले में वर्तमान समय संग्रह में प्रत्येक फ़ाइल के संशोधन समय के रूप में उपयोग किया जाता है। बाद के मामले में संदर्भित प्रतिबद्ध वस्तु में दर्ज किए गए प्रतिबद्ध समय का उपयोग इसके बजाय किया जाता है।

... लेकिन स्पष्ट रूप से दोनों मामलों ने " प्रत्येक फ़ाइल का संशोधन समय" निर्धारित किया ; इस प्रकार उन फ़ाइलों के वास्तविक टाइमस्टैम्प को संरक्षित नहीं करते!

इसलिए, टाइमस्टैम्प को संरक्षित करने के लिए, यहां एक 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

... और उम्मीद है कि एक ही टाइमस्टैम्प देखें (उन फ़ाइलों के लिए जो संस्करण नियंत्रण में थे)।

उम्मीद है कि यह किसी की मदद करता है,
चीयर्स!





svn-export