Сделать «git export» (например, «svn export»)?

Из Руководство по Git:

Использование git-checkout-index для «экспорта всего дерева»

Возможность префикса в основном упрощает использование git-checkout-index в качестве функции «экспорта в виде дерева». Просто прочтите нужное дерево в индексе и выполните:

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

Выяснил, что означает вариант 2. Из репозитория вы можете:

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

Косая черта в конце пути важна, иначе это приведет к тому, что файлы будут находиться в / назначении с префиксом «путь».

Поскольку в нормальной ситуации индекс содержит содержимое репозитория, нет ничего особенного, чтобы «прочитать желаемое дерево в индекс». Это уже есть.

Флаг -a требуется для проверки всех файлов в индексе (я не уверен, что значит опустить этот флаг в этой ситуации, поскольку он не делает того, что я хочу). Флаг -f принудительно перезаписывает любые существующие файлы в выводе, чего эта команда обычно не делает.

Это похоже на то, что я искал.

На самом деле я бы предпочел иметь цель расстояние в вашем Makefile (или другой системе сборки), которая экспортирует распространяемый архив вашего кода (.tar.bz2, .zip, .jar или любой другой подходящий). Если вы используете GNU autotools или системы MakeMaker Perl, я думаю, что это существует для вас автоматически. Если нет, настоятельно рекомендую добавить его.

ETA (06.09.2012): Ого, резкие отрицательные голоса. Я по-прежнему считаю, что лучше создавать свои дистрибутивы с помощью инструментов сборки, а не инструмента управления исходным кодом. Я верю в создание артефактов с помощью инструментов сборки. В моей нынешней работе наш основной продукт построен на мишени-муравьях. Мы находимся в самом разгаре переключения систем управления исходным кодом, и наличие этой цели-муравья означает меньше хлопот при миграции.

Вероятно, самый простой способ добиться этого - использовать 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, он, тем не менее, будет содержать другие скрытые файлы, специфичные для git, такие как .gitignore, .gitattributes и т. д. Если вы не хотите, чтобы они были в архиве, убедитесь, что вы используйте атрибут export-ignore в файле .gitattributes и зафиксируйте его перед созданием архива. Подробнее...

Примечание. Если вас интересует экспорт индекса, используйте следующую команду:

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

(Подробнее см. Ответ Грега)

Я написал простую оболочку для git-checkout-index, которую вы можете использовать следующим образом:

git export ~/the/destination/dir

Если целевой каталог уже существует, вам нужно добавить -f или --force.

Установка проста; просто перетащите скрипт где-нибудь в PATH и убедитесь, что он исполняемый.

Репозиторий github для git-export

git archive также работает с удаленным репозиторием.

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

Чтобы экспортировать конкретный путь внутри репо, добавьте столько путей, сколько хотите, в качестве последнего аргумента в git, например:

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

Похоже, что это меньшая проблема с Git, чем с SVN. Git помещает только папку .git в корень репозитория, тогда как SVN помещает папку .svn в каждый подкаталог. Таким образом, "svn export" избегает рекурсивной магии командной строки, тогда как с Git в рекурсии нет необходимости.

Мне это было нужно для сценария развертывания, и я не мог использовать ни один из вышеупомянутых подходов. Вместо этого я нашел другое решение:

#!/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]. ПРИМЕЧАНИЕ: с помощью этой функции вы избегаете операции клонирования, она получает напрямую из удаленного репо.

gitss() {
    URL=[url:path]

    TMPFILE = "`/bin/tempfile`"
    if [ "" = "" ]; then
        echo -e "Use: gitss repo [tree/commit]\n"
        return
    fi
    if [ "" = "" ]; then
        TREEISH = "HEAD"
    else
        TREEISH = ""
    fi
    echo "Getting /$TREEISH..."
    git archive --format=zip --remote=$URL/ $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]/  \ > $GIT_TMPFILE && unzip $GIT_TMPFILE && rm $GIT_TMPFILE' -

Я просто хочу отметить, что в случае, если вы

1. экспорт подпапки репозитория (так я использовал функцию экспорта SVN)
2. согласны с копированием всего из этой папки в место развертывания
3. и поскольку у вас уже есть копия всего репозитория.

Тогда вы можете просто использовать cp foo [destination] вместо упомянутого git-archive master foo | -x -C [destination].

Это скопирует все содержимое, за исключением файлов .dot. Я использую это для экспорта клонированных проектов git в репозиторий git моего веб-приложения без материала .git.

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

Обычный старый bash отлично работает :)

Я широко использую git-submodules. Это работает для меня:

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

Bash-реализация git-export.

Я сегментировал процессы создания и удаления файлов .empty по их собственной функции с целью их повторного использования в реализации «git-archive» (будет опубликовано позже).

Я также добавил в процесс файл .gitattributes, чтобы удалить ненужные файлы из целевой папки экспорта. Включено подробное описание процесса, что сделало функцию «git-export» более эффективной.

EMPTY_FILE = ". Пустой";

function create_empty () {
## Processing path (target-dir):
    TRG_PATH = "";
## 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 = "";
    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 = "";
    TRG_PATH = "";
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 = ""; SRC_DIR = "";
    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;
  }

Output:

$ git-export /tmp/rel-1.0.0

Adding '.empty' files to empty folder(s): ... done.

Checking-Out Index component(s): ... done.

Resetting HEAD and Index: ... done.

Purging Git-Specific component(s): ...

'/tmp/rel-1.0.0/{.buildpath}' files ... done.'

'/tmp/rel-1.0.0/{.project}' files ... done.'

'/tmp/rel-1.0.0/{.gitignore}' files ... done.'

'/tmp/rel-1.0.0/{.git}' files ... done.'

'/tmp/rel-1.0.0/{.gitattributes}' files ... done.'

'/tmp/rel-1.0.0/{*.mno}' files ... done.'

'/tmp/rel-1.0.0/{*~}' files ... done.'

'/tmp/rel-1.0.0/{.*~}' files ... done.'

'/tmp/rel-1.0.0/{*.swp}' files ... done.'

'/tmp/rel-1.0.0/{*.swo}' files ... done.'

'/tmp/rel-1.0.0/{.DS_Store}' files ... done.'

'/tmp/rel-1.0.0/{.settings}' files ... done.'

'/tmp/rel-1.0.0/{.empty}' files ... done.'

done.

Archiving Checked-Out component(s): ... done.

-rw-r--r-- 1 admin wheel 25445901 3 Nov 12:57 /tmp/rel-1.0.0.tgz

I have now incorporated the 'git archive' functionality into a single process that makes use of 'create_empty' function and other features.

function git-archive () {
    PREFIX = ""; ## sudo mkdir -p ${PREFIX}
    REPO_PATH = "`echo ""|awk -F: '{print }'`";
    RELEASE = "`echo ""|awk -F: '{print }'`";
    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 [[ "" =~ [--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. В моем ответе на этот вопрос рассматриваются три свойства, которые svn export изначально имеет по сравнению с 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.

Эквивалент

svn export . otherpath

внутри существующего репо

git archive branchname | (cd otherpath; tar x)

Эквивалент

svn export url otherpath

является

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

Если вам нужно что-то, что работает с подмодулями, возможно, стоит попробовать.

Примечание:

• MASTER_DIR = проверка с вашими подмодулями, также проверенными
• DEST_DIR = где этот экспорт закончится
• Если у вас есть rsync, я думаю, вы сможете сделать то же самое, но с еще меньшей болью.

Предположения:

• Вам нужно запустить это из родительского каталога MASTER_DIR (то есть из компакт-диска MASTER_DIR ..)
• Предполагается, что 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

Если вам также нужны подмодули, это должно помочь: https://github.com/meitar/git-archive-all.sh/wiki

Вы можете заархивировать удаленное репо в любой фиксации в виде zip-файла.

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

Так же просто, как клонирование, затем удалите папку .git:

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

Ответ в частном случае, если репозиторий размещен на GitHub.

Просто используйте svn export.

Насколько я знаю, Github не поддерживает archive --remote. Хотя GitHub - это svn совместимый, и у них есть все доступные репозитории git svn, поэтому вы можете просто использовать svn export, как обычно, с небольшими изменениями URL-адреса GitHub.

Например, чтобы экспортировать весь репозиторий, обратите внимание, как trunk в URL-адресе заменяет master (или любой другой ветка HEAD проекта установлена ​​на):

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

И вы можете экспортировать отдельный файл или даже определенный путь или папку:

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

Пример с Библиотека jQuery JavaScript

Ветвь 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

Если вы не исключаете файлы с .gitattributesexport-ignore, попробуйте git checkout

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

-f
When checking out paths from the index, do not fail upon unmerged entries; instead, unmerged entries are ignored.

и

-q
Avoid verbose

Кроме того, вы можете получить любую ветку или тег или из определенной версии фиксации, как в SVN, просто добавив SHA1 (SHA1 в Git эквивалентен номеру версии в 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 не удалит файлы, но перезапишет файлы с тем же именем без предупреждения.

ОБНОВИТЬ: Чтобы избежать проблемы с обезглавливанием или оставить нетронутым рабочий репозиторий при использовании checkout для экспорта с тегами, ветвями или 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 -- ./

Обратите внимание, что ./ относится к корню репозитория.

Это скопирует файлы из диапазона коммитов (от C до G) в файл tar. Примечание: при этом будут зафиксированы только файлы. Не весь репозиторий. Немного изменено от Здесь

Пример истории фиксации

А -> В -> 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 ~ -> Включить файлы из коммита C. Не только файлы после коммита C.

| xargs tar -rf myTarFile -> выводит в tar

В моем файле .bashrc есть следующая служебная функция: она создает архив текущей ветки в репозитории git.

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

Я думаю, что сообщение @Aredridel было самым близким, но есть кое-что еще - поэтому я добавлю это здесь; дело в том, что в svn, если вы находитесь в подпапке репо, и вы делаете:

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

тогда svn экспортирует все файлы, которые находятся под контролем версий (они также могли быть недавно добавлены; или измененный статус) - и если у вас есть другой «мусор» в этом каталоге (и я не считаю здесь вложенные папки .svn, но видим такие вещи, как Файлы .o) будет экспортирован нет; будут экспортированы только те файлы, которые зарегистрированы репозиторием SVN. Для меня приятно то, что этот экспорт также включает файлы с локальными изменениями, для которых нет еще был зафиксирован; и еще одна приятная вещь заключается в том, что временные метки экспортируемых файлов такие же, как и у исходных. Или, как говорит svn help export:

2. Exports a clean directory tree from the working copy specified by PATH1, at revision REV if it is given, otherwise at WORKING, into PATH2. ... If REV is not specified, all local changes will be preserved. Files not under version control will not be copied.

Чтобы понять, что 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 archive behaves differently when given a tree ID versus when given a commit ID or tag ID. In the first case the current time is used as the modification time of each file in the archive. In the latter case the commit time as recorded in the referenced commit object is used instead.

... но, видимо, оба случая устанавливают "время модификации файла каждый"; тем самым нет сохраняет фактические временные метки этих файлов!

Итак, чтобы также сохранить временные метки, вот сценарий 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

... и, надеюсь, увидите те же отметки времени (для тех файлов, которые находились под контролем версий).

Надеюсь, это кому-то поможет,
Ваше здоровье!

Для пользователей GitHub метод git archive --remote не будет работать напрямую, как URL экспорта недолговечен. Вы должны попросить GitHub указать URL-адрес, а затем загрузить этот 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

Редактировать
Если вы хотите, чтобы код помещался в конкретный каталог существующий (а не в случайный каталог из github):

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

Да, это - это чистая и аккуратная команда для архивирования вашего кода без включения git в архив, и ее можно передавать, не беспокоясь о истории коммитов git.

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

Безусловно, самый простой способ, который я видел (и также работает с Windows), - это git bundle:

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

Подробнее см. В этом ответе: Как я могу скопировать репозиторий git с моей машины Windows на машину Linux через USB-накопитель?

Вариант 1 звучит не слишком эффективно. Что делать, если в клиенте нет места для клонирования и потом удаляет папку .git?

Сегодня я обнаружил, что пытаюсь сделать это, где клиентом является Raspberry Pi, на котором почти не осталось места. Кроме того, я также хочу исключить из репозитория какую-то тяжелую папку.

Вариант 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, но с своего рода опцией исключения (как задается здесь).

У меня есть другое решение, которое отлично работает, если у вас есть локальная копия репозитория на машине, на которой вы хотите создать экспорт. В этом случае перейдите в этот каталог репозитория и введите эту команду:

GIT_WORK_TREE=outputdirectory git checkout -f

Это особенно полезно, если вы управляете веб-сайтом с помощью репозитория git и хотите проверить чистую версию в /var/www/. В этом случае добавьте эту команду в сценарий .git/hooks/post-receive (hooks/post-receive в голом репозитории, что больше подходит в этой ситуации)

Насколько я понимаю вопрос, это больше касается загрузки только определенного состояния с сервера, без истории и без данных других ветвей, а не извлечения состояния из локального репозитория (как это делают многие другие пользователи).

Это можно сделать так:

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 является (был?) Неисправным по сообщениям, но в случае экспорта упомянутые проблемы не должны иметь значения.

экспорт git в zip-архив с добавлением префикса (например, имени каталога):

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