git-read-tree - Интернет в облаке

ПРОГРАММА:

ИМЯ

git-read-tree - считывает информацию о дереве в индекс

СИНТАКСИС

мерзавец дерево чтения [[-m [--trivial] [--aggressive] | --reset | --prefix = ]
[-u [--exclude-per-directory = ] | -я]]
[--index-output = ] [--no-sparse-checkout]
(- пусто | [ [ ]])

ОПИСАНИЕ

Читает информацию о дереве, предоставленную в индекс, но на самом деле не
обновление любой из файлов, которые он "кэширует". (видеть: git-checkout-индекс(1))

При желании, он может объединить дерево в индекс, выполнить быстрое (т.е. двухстороннее) объединение,
или трехстороннее слияние с флагом -m. При использовании с -m флаг -u заставляет его также
обновить файлы в дереве работы с результатом слияния.

Тривиальные слияния выполняются мерзавец дерево чтения сам. Только конфликтующие пути будут в
не объединенное состояние, когда мерзавец дерево чтения возвращается.

ДОПОЛНИТЕЛЬНЫЕ ОПЦИИ

-m
Выполните слияние, а не только чтение. Команда откажется запускаться, если ваш индексный файл
имеет несвязанные записи, что указывает на то, что вы не завершили предыдущее слияние вас
началась.

--сброс настроек
То же, что и -m, за исключением того, что несоединенные записи удаляются вместо сбоя.

-u
После успешного слияния обновите файлы в дереве работы, добавив результат
слияния.

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

-n, -- пробный запуск
Проверьте, не выдает ли команда ошибку без обновления индекса или файлов в
рабочее дерево по-настоящему.

-v
Показать прогресс извлечения файлов.

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

--агрессивный
Обычно трехстороннее слияние мерзавец дерево чтения разрешает слияние для действительно тривиальных случаев
и оставляет другие дела нерешенными в указателе, чтобы фарфор мог реализовать
разные политики слияния. Этот флаг заставляет команду разрешить еще несколько случаев.
внутри:

· Когда одна сторона удаляет путь, а другая сторона оставляет путь неизменным. В
решение состоит в том, чтобы удалить этот путь.

· Когда обе стороны удаляют путь. Решение состоит в том, чтобы удалить этот путь.

· Когда обе стороны одинаково добавляют путь. Решение состоит в том, чтобы добавить этот путь.

--prefix = /
Сохраните текущее содержимое индекса и прочтите содержимое именованного дерева под
каталог в . Команда откажется перезаписывать записи, которые уже
существовал в исходном индексном файле. Обратите внимание, что / значение должно заканчиваться
слэш.

--exclude-per-directory =
При запуске команды с параметрами -u и -m результат слияния может потребоваться
перезаписывать пути, которые не отслеживаются в текущей ветке. Команда обычно
отказывается продолжить слияние, чтобы не потерять такой путь. Однако эта безопасность
клапан иногда мешает. Например, часто бывает, что другая ветка
добавил файл, который раньше был сгенерированным файлом в вашей ветке, и предохранительный клапан
срабатывает, когда вы пытаетесь переключиться на эту ветку после запуска make, но перед запуском
make clean, чтобы удалить сгенерированный файл. Эта опция указывает команде читать
файл исключения для каждого каталога (обычно .gitignore) и позволяет такое неотслеживаемое, но
явно проигнорированный файл для перезаписи.

--index-output =
Вместо того, чтобы записывать результаты в $ GIT_INDEX_FILE, запишите результирующий индекс в
названный файл. Пока команда работает, исходный индексный файл заблокирован
тот же механизм, что и обычно. Файл должен позволять переименовать(2) из
временный файл, который создается рядом с обычным индексным файлом; обычно это означает это
должен находиться в той же файловой системе, что и сам индексный файл, и вам нужно написать
разрешение на каталоги, в которых находятся индексный файл и выходной файл индекса.

--no-spparse-checkout
Отключите поддержку разреженной проверки, даже если core.sparseCheckout имеет значение true.

--пустой
Вместо того, чтобы читать древовидные объекты в индексе, просто очистите его.


Идентификатор объекта (ов) дерева для чтения / слияния.

СЛИЯНИЕ

Если указан -m, мерзавец дерево чтения может выполнять 3 вида слияния, слияние одного дерева, если
дается только 1 дерево, быстрое слияние с 2 деревьями или 3-стороннее слияние, если 3 дерева
при условии.

Один дерево идти
Если указано только 1 дерево, мерзавец дерево чтения работает так, как если бы пользователь не указал -m,
за исключением того, что если в исходном индексе есть запись для данного пути, а содержимое
путь совпадает с читаемым деревом, используется статистика из индекса. (В других
слова, stat () индекса имеют приоритет над объединенным деревом).

Это означает, что если вы выполните команду git read-tree -m за которым следует git checkout-index -f
-u -a, мерзавец кассовый индекс проверяет только то, что действительно изменилось.

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

Две дерево идти
Обычно это вызывается как git read-tree -m $ H $ M, где $ H - это начальная фиксация
текущий репозиторий, а $ M - глава чужого дерева, которое просто опережает $ H
(т.е. мы находимся в ситуации быстрой перемотки вперед).

Когда указаны два дерева, пользователь сообщает мерзавец дерево чтения следующие:

1. Текущий индекс и рабочее дерево являются производными от $ H, но у пользователя может быть локальный
меняется в них с $ H.

2. Пользователь хочет быстро перейти к $ M.

В этом случае команда git read-tree -m $ H $ M гарантирует, что никакие локальные изменения не будут потеряны.
в результате этого «слияния». Вот правила «переноса», где «I» обозначает
index, «чистый» означает, что индекс и дерево работ совпадают, а «существует» / «ничего» относится к
наличие пути в указанном коммите:

Результат IHM
-------------------------------------------------- -----
0 ничего ничего ничего (не бывает)
1 ничего, ничего не существует, используйте M
2 ничего не существует ничего удалить путь из индекса
3 ничего не существует, используйте M, если "начальная проверка",
H == M сохранить индекс в противном случае
существует, провал
H! = M

чистый I == HI == M
------------------
4 да N / AN / A ничего не сохраняйте индекс
5 нет N / AN / A ничего не сохраняю индекс

6 да н / п да ничего не существует сохранить индекс
7 нет н / п да ничего не существует сохранить индекс
8 да н / п нет ничего не существует сбой
9 нет н / п нет ничего не существует сбой

10 да да н / д не существует ничего удалить путь из индекса
11 нет да н / д существует ничего не вышло
12 да нет н / д существует ничего не вышло
13 нет нет нет нет ничего нет сбой

чистый (H == M)
------
14 да существует существует сохранить индекс
15 нет существует сохранить индекс

чистый I == HI == M (H! = M)
------------------
16 да нет нет существует существует сбой
17 нет нет нет существует существует сбой
18 да нет да существует существует сохранить индекс
19 нет нет да существует существует сохранить индекс
20 да да нет существует существует используйте M
21 нет да нет существует существует сбой

Во всех случаях «сохранить индекс» запись индекса остается такой же, как в исходном индексном файле. Если
запись не актуальна, мерзавец дерево чтения сохраняет копию в рабочем дереве нетронутой, когда
работает под флагом -u.

Когда эта форма мерзавец дерево чтения успешно возвращается, вы можете увидеть, какой из "локальных"
внесенные вами изменения были перенесены с помощью команды git diff-index --cached $ M. Примечание.
что это не обязательно соответствует тому, что git diff-index --cached $ H произвел бы
до того, как такое слияние двух деревьев. Это из-за случаев 18 и 19 --- если у вас уже были
изменения в $ M (например, возможно, вы получили его по электронной почте в форме патча), git diff-index
--cached $ H сообщил бы вам об изменении до этого слияния, но не отобразил бы
в git diff-index --cached $ M вывод после слияния двух деревьев.

Случай 3 немного сложен и требует объяснения. Логический результат этого правила
следует удалить путь, если пользователь поставил удаление пути, а затем переключил
в новую ветку. Однако это предотвратит первоначальную проверку, поэтому
Правило модифицируется для использования M (новое дерево) только тогда, когда содержимое индекса пусто.
В противном случае удаление пути сохраняется до тех пор, пока $ H и $ M совпадают.

3-Way идти
Каждая «индексная» запись имеет два бита состояния «стадии». стадия 0 - нормальная, и
единственный, который вы можете увидеть при любом обычном использовании.

Однако, когда вы это сделаете мерзавец дерево чтения с тремя деревьями «этап» начинается с 1.

Это означает, что вы можете делать

$ git дерево чтения -m

и вы получите индекс со всеми записи в "stage1", все
записи в "stage2" и все записи в "stage2". При выполнении
слияние другой ветви с текущей ветвью, мы используем дерево общих предков как
, текущая глава ветки как , а голова другой ветви - как .

Кроме того, мерзавец дерево чтения имеет логику особого случая, которая гласит: если вы видите файл,
соответствует во всех отношениях в следующих состояниях, он "сворачивается" обратно в "stage0":

· 2-й и 3-й этапы совпадают; взять то или другое (без разницы - то же самое
по нашей ветке на этапе 2 и их ветке на этапе 3 были проделаны работы)

· Этап 1 и этап 2 одинаковы, а этап 3 отличается; пройдите 3 этап (наша ветка в
этап 2 ничего не делал, так как предок на этапе 1, а их ветвь на этапе
3 над ней работали)

· Этап 1 и этап 3 одинаковы, а этап 2 отличается от этапа 2 (мы сделали
что-то пока ничего не делали)

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

Хорошо, все это звучит как набор совершенно бессмысленных правил, но на самом деле это
именно то, что вы хотите для быстрого слияния. Различные этапы представляют собой
"результирующее дерево" (этап 0, также известное как "объединенное"), исходное дерево (этап 1, также известное как "ориг") и
два дерева, которые вы пытаетесь объединить (этап 2 и 3 соответственно).

Порядок этапов 1, 2 и 3 (отсюда порядок трех командная строка
аргументы) важны, когда вы начинаете трехстороннее слияние с индексным файлом, который уже
заселен. Вот краткое описание того, как работает алгоритм:

· Если файл одинакового формата существует во всех трех деревьях, он автоматически
коллапс в "объединенное" состояние мерзавец дерево чтения.

· Файл с любой разница что-нибудь в трех деревьях останется отдельными
записи в указателе. «Политика фарфора» решает, как удалить
этапов, отличных от 0, и вставьте объединенную версию.

· Индексный файл сохраняет и восстанавливает всю эту информацию, так что вы можете объединить вещи
постепенно, но до тех пор, пока в нем есть записи на этапах 1/2/3 (т. е. "не объединенные
записей "), вы не можете записать результат. Итак, теперь алгоритм слияния оказывается действительно
просто:

· Вы просматриваете индекс по порядку и игнорируете все записи этапа 0, так как они
уже сделано.

· Если вы найдете "stage1", но не найдете подходящих "stage2" или "stage3", вы знаете, что это было
удаляется с обоих деревьев (он существовал только в исходном дереве), и вы удаляете
эта запись.

· Если вы найдете совпадающее дерево "stage2" и "stage3", вы удалите одно из них и
превратите другую в запись "stage0". Удалите любую совпадающую запись "stage1", если она
тоже существует. .. все нормальные банальные правила ..

Обычно вы использовали бы мерзавец индекс слияния с поставляемым мерзавец объединить один файл сделать это последним
шаг. Скрипт обновляет файлы в рабочем дереве по мере объединения каждого пути и в
конец успешного слияния.

Когда вы начинаете трехстороннее слияние с уже заполненным индексным файлом, предполагается, что
что он представляет состояние файлов в вашем рабочем дереве, и вы даже можете иметь файлы
с незарегистрированными изменениями в индексном файле. Далее предполагается, что это состояние
"полученный" из дерева стадии 2. Трехстороннее слияние отказывается запускаться, если находит запись в
исходный индексный файл, не соответствующий этапу 2.

Это сделано для того, чтобы вы не потеряли незавершенные изменения и не смешали
случайные изменения в несвязанном коммите слияния. Для иллюстрации предположим, что вы начинаете с чего
был последний раз зафиксирован в вашем репозитории:

$ JC = `git rev-parse --verify" HEAD ^ 0 "`
$ git checkout-index -f -u -a $ JC

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

$ git fetch git: // .... linus
$ LT = `git rev-parse FETCH_HEAD`

Ваше дерево работы по-прежнему основано на вашем HEAD ($ JC), но с тех пор у вас есть некоторые изменения. Трехходовой
merge гарантирует, что вы не добавляли и не изменяли записи указателя с $ JC, и если вы
нет, то поступает правильно. Итак, в следующей последовательности:

$ git дерево чтения -m -u `git merge-base $ JC $ LT` $ JC $ LT
$ git слияние-индекс git-слияние-один-файл -a
$ echo "Слияние с Линусом" |
git commit-tree `git write-tree` -p $ JC -p $ LT

то, что вы бы совершили, - это чистое слияние между $ JC и $ LT без вашей незавершенной работы
изменения, и ваше дерево работы будет обновлено до результата слияния.

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

Другими словами, не нужно беспокоиться о том, что существует только в рабочем дереве. Когда
у вас есть локальные изменения в части проекта, которая не участвует в слиянии, ваш
изменения не мешают слиянию и остаются без изменений. Когда они do вмешиваться,
слияние даже не начинается (мерзавец дерево чтения громко жалуется и терпит неудачу без изменения
что-нибудь). В таком случае вы можете просто продолжать делать то, что вы были в середине
делает, и когда ваше рабочее дерево будет готово (то есть вы закончили свою незавершенную работу),
повторите попытку слияния.

SPARSE Купить

«Редкая проверка» позволяет нечасто заполнять рабочий каталог. Он использует
бит skip-worktree (см. git-обновление-индекс(1)), чтобы сообщить Git, находится ли файл в рабочем
каталог стоит посмотреть.

мерзавец дерево чтения и другие команды на основе слияния (мерзавец слияние, мерзавец контроль...) может помочь
поддержание растрового изображения рабочего дерева пропуска и обновление рабочего каталога.
$ GIT_DIR / info / sparse-checkout используется для определения растрового изображения ссылки на рабочее дерево пропуска. Когда
мерзавец дерево чтения необходимо обновить рабочий каталог, он сбрасывает бит skip-worktree в
индекс, основанный на этом файле, который использует тот же синтаксис, что и файлы .gitignore. Если запись
соответствует шаблону в этом файле, skip-worktree не будет устанавливаться для этой записи. Иначе,
skip-worktree будет установлен.

Затем он сравнивает новое значение skip-worktree с предыдущим. Если пропустить-рабочее дерево поворачивает
от установленного до неустановленного, он добавит соответствующий файл обратно. Если он переходит из неустановленного в установленное,
этот файл будет удален.

Хотя $ GIT_DIR / info / sparse-checkout обычно используется для указания файлов, вы можете
также укажите, какие файлы in, используя паттерны отрицания. Например, чтобы удалить файл
нежелательные:

/*
! нежелательный

Еще одна сложная задача - полностью повторно заполнить рабочий каталог, когда вы больше не хотите
скудная касса. Вы не можете просто отключить "разреженную проверку", потому что биты пропуска рабочего дерева
все еще в индексе, а ваш рабочий каталог все еще редко заполнен. Вам следует
повторно заполните рабочий каталог содержимым файла $ GIT_DIR / info / sparse-checkout как
следующим образом:

/*

Затем вы можете отключить разреженную проверку. Небольшая поддержка при оформлении заказа в мерзавец дерево чтения и тому подобное
команды отключены по умолчанию. Вам необходимо включить core.sparseCheckout, чтобы
скудная кассовая поддержка.

Используйте git-read-tree онлайн с помощью сервисов onworks.net