Есть ли "экспорт git" (например, "экспорт svn")?

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

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

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

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

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

похоже, это своего рода "экспорт git", который я искал.

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

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

просто использовать svn export.

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

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

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

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

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

пример библиотека JavaScript jQuery

The 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 Manual:

использование 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, и убедитесь, что это исполняемый файл.

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

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

в эквиваленте

svn export . otherpath

внутри существующего РЕПО

git archive branchname | (cd otherpath; tar x)

в эквиваленте

svn export url otherpath

и

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

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

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

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

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

- f
При проверке путей из индекса, не терпите неудачу на несвязанных записи; вместо этого несвязанные записи игнорируются.

и

- q
Избегайте многословных

кроме того, вы можете получить любую ветку или тег или из конкретной версии фиксации, как в 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 -- ./

The /path/to/checkout/ должен быть пуст, Git не будет удалять файлы, но будет перезаписывать файлы с тем же именем без предупреждения

обновление: Чтобы избежать обезглавленной проблемы или оставить нетронутым рабочий репозиторий при использовании checkout for export с тегами, ветвями или 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-клонированных проектов в Git-РЕПО моего веб-приложения без него .мерзавцы.

cp-R ./путь к Git-РЕПО /путь/к/назначения/

простой старый Баш работает просто отлично :)

Я часто попадал на эту страницу при поиске способа экспорта репозитория 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.

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

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

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

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

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

для пользователей 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

---

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

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

вы можете архивировать удаленное РЕПО в любой фиксации в виде zip-файла.

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

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

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

Bash-реализация git-экспорта.

Я сегментирован .пустые процессы создания и удаления файлов по собственной функции, с целью повторного использования их в реализации "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;
  }

выход:

$ git-export /tmp / rel-1.0.0

добавить '.пустые файлы в пустую папку(ы): ... сделанный.

компонент(ы) индекса извлечения: ... сделанный.

сброс головки и индекса: ... сделанный.

продувка Git-специфического компонента (ов):...

' /tmp/rel-1.0.0 / {.файлы buildpath}'... сделанный.-

' /tmp/rel-1.0.0 / {.файл проекта. .. сделанный.-

' /tmp/rel-1.0.0 / {.файлы гитюдного}'... сделанный.-

' /tmp/rel-1.0.0 / {.git}' файлы ... сделанный.-

' /tmp/rel-1.0.0 / {.файлами gitattributes}'... сделанный.-

' /tmp/rel-1.0.0 / {*.мно}' файлы ... сделанный.-

'/tmp/ rel-1.0.0 / {*~} ' файлы ... сделанный.-

' /tmp/rel-1.0.0 / {.*~}' архив. .. сделанный.-

' /tmp/rel-1.0.0 / {*.ППВ}' файлы ... сделанный.-

' /tmp/rel-1.0.0 / {*.меча}' файлы ... сделанный.-

' /tmp/rel-1.0.0 / {.Файлы DS_Store}'... сделанный.-

' /tmp/rel-1.0.0 / {.файл настроек. .. сделанный.-

' /tmp/rel-1.0.0 / {.пустой файл. .. сделанный.-

сделано.

Архивация извлеченных компонентов: ... сделанный.

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

теперь я включил функциональность "git архив" в один процесс, который использует функцию "create_empty" и другие функции.

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;
  }

Если вы хотите что-то, что работает с подмодулями, это может стоить того.

Примечание:

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

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

• вам нужно запустить это из родительского каталога MASTER_DIR ( т. е. из MASTER_DIR компакт-диска .. )
• предполагается, что DEST_DIR был создан. Это довольно легко изменить, чтобы включить создание DEST_DIR, если вы хотите

cd MASTER_DIR && tar-zcvf ../Печатает/экспорт.смола.gz -- exclude='.мерзавец'* . && компакт. ./ DEST_DIR / & & tar xvfz export.смола.экспорт gz && rm.смола.ГЗ

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

Пример Фиксации Истории

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 --> рекурсия в поддеревья

--нет фиксации-идентификатор --> ГИТ дифф-дерево выдает строка с идентификатором фиксации, когда это применимо. Этот флаг подавил вывод идентификатора фиксации.

--name-only -- > показывать только имена измененных файлов.

--diff-filter=ACMRT -- > выберите только эти файлы. смотрите здесь полный список файлов

C..G --> файлы в этом диапазоне коммитов

С~ --> включаемые файлы от совершения С. Не просто файлов после совершения С.

| xargs tar-rf myTarFile -- > выходы в tar

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

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

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

#!/bin/sh
[ $# -eq 2 ] || echo "USAGE  REPOSITORY DESTINATION" && exit 1
REPOSITORY=
DESTINATION=
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 проекты, он всегда переходит к базовому dir ранее как сказал Здесь, пока это не будет исправлено, я лично предпочитаю функцию

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

я думаю @Aredridelпост был ближе всего, но есть немного больше к этому - так что я добавлю это здесь; дело в том, что в svn, если вы находитесь в подпапке РЕПО, и вы делаете:

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

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

1. экспортирует чистое дерево каталогов из рабочей копии, указанной ПУТЬ1, в редакции пересм если оно дается, в противном случае на работе, в ПУТЬ2. ... Если 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 переменные среды. Обратите внимание, что с помощью этого скрипта, вы должны создать вручную, перед запуском скрипта.

после запуска скрипта, вы должны быть в состоянии сравнить:

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

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

надеюсь, это кому-то поможет,
Ура!

На сегодняшний день самый простой способ я видел, чтобы сделать это (и работает на Windows, а) составляет git bundle:

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

посмотреть этот ответ для более подробной информации: как я могу скопировать репозиторий git с моей машины windows на машину linux через usb-накопитель?

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

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

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

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

У меня есть следующая функция полезности в моем .файл 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
}

Вариант 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 на "голый" репозиторий, который больше подходит в данной ситуации)