Продолжаем марафон утилит, которые я беру с собой от проекта к проекту практически без изменений.

## 💊 Проблема и решение
Знакомая ситуация: на проекте запущено 5 разных тестовых стендов для заказчиков, аналитиков и QA. Фронтендеру нужно постоянно следить, чтобы на конкретном инстансе крутилась именно та ветка, которую сейчас должны тестировать. Делать это вручную - сущий ад: нужно переключиться на ветку, сделать pull, сбросить локальные изменения, зафорсить в нужный стенд... Ошибся одной буквой в консоли либо перепутал ветки - и обновил не тот (либо сломал чужой) стенд.

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

<Alert
type='info'
header='Финальная версия'
text='Перед тем как отдать на растерзание тетировщикам новую фичу (накатить ее на тестовый инстанс), нужно синхронизировать удаленную ветку `test` с удаленной веткой `stable`, вам нужно вызвать этот скрипт без передачи аргументов.
Поскольку в коде уже зашиты нужные вам значения по умолчанию (`DEFAULT_DEST="test"` и `DEFAULT_SOURCE="stable"`), скрипт сам подставит их.'
/>

## 🔥 Способы вызова скрипта
Перед запуском убедитесь, что ваш терминал открыт в корне Git-репозитория.

### Вариант 1: Безопасный просмотр (Рекомендуется)
Флаг `--dry-run` покажет, какие коммиты будут удалены или добавлены, но не внесет никаких изменений в Git:
```bash
bash _aux.sync-branches.sh --dry-run
```

### Вариант 2: Прямая синхронизация
Запуск в обычном режиме. Скрипт автоматически запросит подтверждение (y/n) перед сбросом веток:
```bash
bash _aux.sync-branches.sh
```

### Вариант 3: Явное указание веток
Вы можете вручную переопределить ветки. Аргументы передаются в порядке 👉 **[КУДА] [ОТКУДА]**:

```bash
bash _aux.sync-branches.sh test stable
```

## ⚙️ Как это работает под капотом
- Обновление данных: Скрипт выполняет `git fetch origin`, запрашивая свежую историю из удаленного репозитория;
- Локальный сброс: Операция сброса веток (`git reset --hard`) происходит локально на вашем компьютере;
- Пуш в сеть: Результат отправляется в удаленный репозиторий через `git push --force`;

<Alert
type='danger'
header='Важное замечание по работе скрипта'
text='Скрипт выполняет команду `git fetch origin`. Это значит, что для анализа изменений он использует самые свежие данные из удаленного репозитория
Однако, саму операцию сброса (`git reset --hard`) он делает локально на вашем компьютере, после чего отправляет результат в сеть через `git push --force`.
⚠️ Поэтому соблюдайте два правила 👇
1️⃣ **У вас не должно быть незакоммиченных изменений в локальном репозитории;**
2️⃣ **Не работайте с локальной веткой `test` - она будет перезаписана каждый раз при использовании этого механизма синхронизации;**'
/>

## 🚀 Код скрипта
`_aux.sync-branches.sh`
```bash
#!/usr/bin/env bash

# NOTE: 1. ПЕРЕМЕННЫЕ ПО УМОЛЧАНИЮ
DEFAULT_DEST="test"
DEFAULT_SOURCE="stable"

DRY_RUN=false
# NOTE: Проверяем наличие флага --dry-run
for arg in "$@"; do
    if [ "$arg" == "--dry-run" ]; then DRY_RUN=true; fi
done

# UPD: Безопасная очистка аргументов от флага без использования внешних утилит (sed)
ARGS=()
for arg in "$@"; do
    [[ "$arg" != "--dry-run" ]] && ARGS+=("$arg")
done

# UPD: Извлекаем элементы из правильно сформированного массива
DEST_BRANCH=${ARGS[0]:-$DEFAULT_DEST}
SOURCE_BRANCH=${ARGS[1]:-$DEFAULT_SOURCE}

# Логика определения целевой точки (если передан только 1 аргумент - это коммит для test)
if [ ${#ARGS[@]} -eq 1 ] && [ "${ARGS[0]}" != "prod" ] && [ "${ARGS[0]}" != "dev" ]; then
    TARGET_POINT=${ARGS[0]}
    DEST_BRANCH=$DEFAULT_DEST
else
    TARGET_POINT=$SOURCE_BRANCH
fi

START_BRANCH=$(git rev-parse --abbrev-ref HEAD)

# -- NOTE: Возврат при ошибках
# Функция вернет вас на исходную ветку, даже если скрипт упадет или вы нажмете Ctrl+C
cleanup() {
    local exit_code=$?
    trap - EXIT INT TERM # Предотвращаем бесконечный рекурсивный цикл trap
    echo "🔄 Возврат на исходную ветку: $START_BRANCH"
    git checkout "$START_BRANCH" >/dev/null 2>&1
    exit $exit_code
}
trap cleanup EXIT INT TERM
# --

TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_PREFIX="backup/${DEST_BRANCH}"
BACKUP_BRANCH="${BACKUP_PREFIX}_${TIMESTAMP}"

echo "📡 Обновление данных из origin..."
git fetch origin --prune

# --- NOTE: 2. Проверка существования целевой точки
if ! git rev-parse --verify "$TARGET_POINT" >/dev/null 2>&1; then
    echo "❌ Ошибка: Точка '$TARGET_POINT' не найдена."
    exit 1
fi
TARGET_SHA=$(git rev-parse "$TARGET_POINT")
# ---

# --- NOTE: 3. Анализ расхождений
REMOTE_DIFF=$(git rev-list --count "$TARGET_SHA..origin/$DEST_BRANCH" 2>/dev/null || echo 0)
LOCAL_DIFF=$(git rev-list --count "$TARGET_SHA..$DEST_BRANCH" 2>/dev/null || echo 0)

# UPD: Проверка на "обратное отставание"
BEHIND_COUNT=$(git rev-list --count "$DEST_BRANCH..$TARGET_SHA" 2>/dev/null || echo 0)

if [ "$BEHIND_COUNT" -eq 0 ] && [ "$REMOTE_DIFF" -eq 0 ] && [ "$LOCAL_DIFF" -eq 0 ]; then
    echo "✅ Ветки идентичны. Синхронизация не требуется."
    exit 0
fi

# Если источник (TARGET_SHA) сам отстает от цели (DEST_BRANCH)
if [ "$BEHIND_COUNT" -eq 0 ] && ([ "$REMOTE_DIFF" -gt 0 ] || [ "$LOCAL_DIFF" -gt 0 ]); then
    echo "⚠️  ВНИМАНИЕ: Кажется, ветки перепутаны местами!"
    echo "В целевой ветке [$DEST_BRANCH] ЕСТЬ новые коммиты, а в источнике [$TARGET_POINT] их НЕТ."
    echo "Сброс приведет к откату кода назад."
    read -p "Вы уверены, что хотите ОТКАТИТЬ $DEST_BRANCH к состоянию $TARGET_POINT? (y/n): " reverse_confirm
    [[ $reverse_confirm != "y" ]] && { echo "❌ Отмена."; exit 1; }
fi
# ---

# --- ПРОВЕРКА РАЗНИЦЫ (основная логика) ---
print_boxed_log() {
    local title="$1"
    local log_content="$2"

    # Если лог пустой, ничего не выводим
    [[ -z "$log_content" ]] && return

    # Определяем ширину рамки (минимум 60 символов, либо по ширине терминала - 4 символа для отступов)
    local term_width=$(tput cols 2>/dev/null || echo 80)
    local width=$(( term_width > 80 ? 80 : term_width - 4 ))
    [[ $width -lt 60 ]] && width=60

    # Линии рамки
    local horizontal_line=$(printf '─%.0s' $(seq 1 $width))

    # Верхняя граница
    echo -e "\e[33m┌${horizontal_line}┐\e[0m"

    # Заголовок блока
    printf "\e[33m│\e[0m %-${width}s \e[33m│\e[0m\n" "$title"
    echo -e "\e[33m├${horizontal_line}┤\e[0m"

    # Вывод строк лога с обрезкой по ширине, если они слишком длинные
    echo "$log_content" | while read -r line; do
        # Очищаем строку от спецсимволов, если нужно, и форматируем под рамку
        # Если строка длиннее рамки, она аккуратно обрезается, чтобы не ломать край
        if [ ${#line} -gt $((width - 2)) ]; then
            line="${line:0:$((width - 5))}..."
        fi
        printf "\e[33m│\e[0m %-$((width - 1))s \e[33m│\e[0m\n" "$line"
    done

    # Нижная граница
    echo -e "\e[33m└${horizontal_line}┘\e[0m"
}
if [ "$REMOTE_DIFF" -gt 0 ] || [ "$LOCAL_DIFF" -gt 0 ]; then
    echo "ℹ️  Цель [$DEST_BRANCH] получит $BEHIND_COUNT новых коммитов из [$TARGET_POINT]."
    echo -e "\e[31m⚠️  Будут УДАЛЕНЫ уникальные изменения из целевой ветки!\e[0m"
    echo ""

    # Собираем логи в переменные, используя origin/, чтобы избежать ошибки "unknown revision"
    # Также убираем дубликаты коммитов через sort -u
    LOCAL_LOG=$(git log --oneline "$TARGET_SHA..$DEST_BRANCH" 2>/dev/null || true)
    REMOTE_LOG=$(git log --oneline "$TARGET_SHA..origin/$DEST_BRANCH" 2>/dev/null || true)
    COMBINED_LOG=$(echo -e "${LOCAL_LOG}\n${REMOTE_LOG}" | grep -v '^$' | sort -u)

    # Выводим красивый блок
    print_boxed_log "Изменения на УДАЛЕНИЕ из [$DEST_BRANCH]:" "$COMBINED_LOG"
    echo ""

    if [ "$DRY_RUN" = true ]; then
        echo "🔍 [DRY-RUN]: Режим просмотра. Выход."
        exit 0
    fi

    read -p "Создать бэкап и перезаписать $DEST_BRANCH? (y/n): " confirm
    [[ $confirm != "y" ]] && { echo "❌ Отмена."; exit 1; }
fi
# ---

# --- NOTE: ВЫПОЛНЕНИЕ ---
# Проверяем чистоту рабочего каталога перед переключением
if ! git diff-index --quiet HEAD --; then
    echo "❌ Ошибка: У вас есть незакоммиченные изменения. Сделайте stash или commit."
    exit 1
fi

git checkout "$DEST_BRANCH"
echo "📦 Бэкап: $BACKUP_BRANCH"
git checkout -b "$BACKUP_BRANCH" && git push origin "$BACKUP_BRANCH"
git checkout "$DEST_BRANCH"

echo "🧹 Сброс $DEST_BRANCH до $TARGET_SHA..."
git reset --hard "$TARGET_SHA" && git push origin "$DEST_BRANCH" --force

# NOTE: Чистка бэкапов (удаленных и локальных)
THRESHOLD_DATE=$(date -d "7 days ago" +%Y%m%d 2>/dev/null || date -v-7d +%Y%m%d)

# Получаем уникальный список старых бэкапов (и локальных, и удаленных)
DELETED_BRANCHES=()
while read -r branch; do
    CLEAN_NAME=$(echo "$branch" | sed -E 's|[* ]+||g; s|remotes/origin/||; s|origin/||')

    # Проверяем, не обрабатывали ли мы эту ветку уже
    if [[ ! " ${DELETED_BRANCHES[@]} " =~ " ${CLEAN_NAME} " ]]; then
        BRANCH_DATE=$(echo "$CLEAN_NAME" | grep -oE '[0-9]{8}')

        if [ ! -z "$BRANCH_DATE" ] && [ "$BRANCH_DATE" -lt "$THRESHOLD_DATE" ]; then
            echo "🗑️ Удаляю старый бэкап: $CLEAN_NAME"
            git push origin --delete "$CLEAN_NAME" >/dev/null 2>&1
            git branch -D "$CLEAN_NAME" >/dev/null 2>&1
            DELETED_BRANCHES+=("$CLEAN_NAME")
        fi
    fi
done < <(git branch -a | grep "${BACKUP_PREFIX}_")
# ---

echo "✅ ГОТОВО! Ветка $DEST_BRANCH синхронизирована с $TARGET_POINT"
```

Job [2026.5] part 2 🎓 Синхронизация веток #git #bash #рабочие_моменты

Чтобы узнать длительность проекта (время от первого до последнего коммита), используйте команду, которая находит даты первого и последнего коммитов в ветке. Лучший способ — объединить поиск первого коммита и последнего коммита через git log.

```bash
git log --reverse --format="%ad" | head -1; git log -1 --format="%ad"
```

Что делает эта команда:
- `git log --reverse --format="%ad" | head -1` 👉 Выводит все коммиты от старых к новым, форматирует их как даты и берет самую первую строку (самый старый коммит).
- `;` Разделитель команд.
- `git log -1 --format="%ad"` 👉 Выводит дату самого последнего коммита (HEAD). 

Результат будет выглядеть как две строки с датами.

Чтобы получить результат в формате «лет, недель, дней и часов» по всей истории проекта, одной команды Git недостаточно — нужно подключить небольшое вычисление через терминал.
Если вы на macOS или Linux, используйте этот скрипт:
```bash
# Получаем даты первого и последнего коммита во всех ветках в формате Unix timestamp
start=$(git log --all --format=%ct | sort -n | head -1)
end=$(git log --all --format=%ct | sort -n | tail -1)

# Вычисляем разницу в секундах
diff=$((end - start))

# Переводим в годы, недели, дни и часы
years=$((diff / 31536000))
weeks=$(((diff % 31536000) / 604800))
days=$(((diff % 604800) / 86400))
hours=$(((diff % 86400) / 3600))

echo "${years}y ${weeks}w ${days}d ${hours}h"
```

Как это работает:
- `git log --all --format=%ct` 👉 достает время всех коммитов во всех ветках в секундах.
- `sort -n` 👉 сортирует их, чтобы найти самый ранний и самый поздний моменты.
- Математический блок: делит общую разницу на количество секунд в году (31.5 млн), неделе (604к) и так далее.

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

Самый простой вариант (по алфавиту):
```bash
git log --all --format='%aN' | sort -u
```
- `--all` 👉 ищет во всех ветках.
- `--format='%aN'` 👉 выводит только имена авторов.
- `sort -u` 👉 сортирует и убирает дубликаты.

Если нужна статистика (кто сделал больше всех):
Чаще всего используют эту команду, так как она сразу показывает количество коммитов каждого автора:
```bash
git shortlog -sn --all
```
- `-s` (summary): подавляет вывод описаний коммитов, оставляя только итог.
- `-n` (numbered): сортирует список по убыванию количества коммитов.

Узнать, сколько коммитов сделал каждый автор с начала 2024 года:
```bash
git shortlog -sn --all --since="2024-01-01"
```

#git | Узнать длительность проекта; Статистика по авторам

> How to create a git patch from the uncommitted changes in the current working directory without creating a commit?

If you haven't yet commited the changes, then:
```shell
git diff > mypatch.patch
# New file will be created in current dir
```

But sometimes it happens that part of the stuff you're doing are new files that are untracked and won't be in your `git diff` output. So, one way to do a patch is to stage everything for a new commit (`git add <each file>`, or just `git add .`) but don't do the commit, and then:
```shell
git diff --cached > mypatch.patch
```
Add the 'binary' option if you want to add binary files to the patch (e.g. mp3 files):
```shell
git diff --cached --binary > mypatch.patch
```
You can later apply the patch:
```shell
git apply mypatch.patch
```

### 🎓 *See also answer:*
```shell
git diff # for unstaged changes.
git diff --cached # for staged changes.
git diff HEAD # for both staged and unstaged changes.
```
[Source](https://stackoverflow.com/questions/5159185/how-to-create-a-git-patch-from-the-uncommitted-changes-in-the-current-working-di)

#git | Patch // How to create a git patch from the uncommitted changes in the current working directory without creating a commit?

*For Windows:*
```shell
git config --global core.autocrlf true
```
*For Linux:*
```shell
git config --global core.autocrlf input
```
<Alert type='default'
header='[Git for Windows: работа с параметром `core.autocrlf`](https://habr.com/ru/articles/703072/)'
text='Собственно, параметр «core.autocrlf» придумали для обеспечения работы над одним проектом программистов из разных операционных систем. Предполагается, что программист в операционной системе «Windows» будет работать с файлами, в которых окончания строк только вида CRLF. При этом предполагается, что он включит для проекта настройку «core.autocrlf» со значением «true». Тогда он будет работать в своей папке проекта с файлами, в которых окончания строк будут вида CRLF, при этом в базе данных «Git» эти же файлы будут сохранены с окончаниями вида LF. Программист в операционной системе «Windows» этого даже не заметит, ведь конвертация происходит автоматически, как было показано выше в пункте 1.'
/>

See also [Настройка Git для обработки окончаний строк](https://docs.github.com/ru/get-started/getting-started-with-git/configuring-git-to-handle-line-endings)

#git | Line endings details [core.autocrlf]

Это дополнение к `git pull/fetch`, которое нужно запускать в тех редких случаях, когда изменяются сабмодули, они сами не переключаются в рабочей копии.

```bash
git submodule update
```

<Alert type='info' header='[See also doc](https://git-scm.com/book/en/v2/Git-Tools-Submodules)' text='Часто случается (вот это, кстати, спорный момент), что во время работы над одним проектом вам необходимо использовать другой проект изнутри него. Возможно, это библиотека, разработанная третьей стороной или которую вы разрабатываете отдельно и используете в нескольких родительских проектах. В этих сценариях возникает общая проблема: вы хотите иметь возможность рассматривать два проекта как отдельные, но при этом иметь возможность использовать один из другого.' />

About #git submodule

кстати, полезная команда на мастере: 

```bash
git co origin/feature/IT-2332 common/styled-mui/template/dev-tools/FixedMsg/FixedMsg.tsx
```

(«взять из этого коммита вот этот файл»)

И удобно, и относительно гарантирует от конфликтов при слиянии этой ветки в мастер.

#git | co «взять из этого коммита вот этот файл»

> Чтоб перенести коммит в текущую ветку, достаточно знать его HASH

## anyway

```bash
# Войти в ветку в которую хотим перенести изменения
git checkout master
```

## note 1

### 1. base

```bash
# Дописываем коммиты по одному в текущую ветку
git cherry-pick <HASH>
```

### 2. Полезные опции

#### 2.1 `-edit`

Удобно для правки commit msg при переносе коммита (чтоб не использовать потом интерактивный rebase или что-то еще). В этом случае при выполнении cherry-pick git запросит новый commit msg для Вашего коммита, который Вы переносите в новую ветку; если Вы его не добавляете, то cmt переносится с тем же msg, что был в исходной ветке.

```bash
git cherry-pick <HASH> -edit
```

#### 2.2. `--no-commit` move changes to working directory

Вместо того, чтоб создавать новый коммит в результирующей ветке, берет все изменения, сделанные в этом коммите и просто помещает их в working directory. Это удобно чтоб дорабатывать переносимый коммит.

```bash
git cherry-pick <HASH> --no-commit
```

<YoutubePlayer videoId='GZgswRhTHK8' />

## ~~note 2 (sp)~~

ну смотри, делаешь ещё одну ветку, например `feature/IT-2257-master` (просто от мастера) и потом уже в неё заходишь и делаешь

```bash
git cherry-pick <HASH>
```

коммит прилетит в текущую из другой ветки. как я помню надо от старого к новому пикать по одному

#git | cherry-pick

## CMD sample
```bash
GIT_SHA1=$(git show --format=\"%h\" --no-patch) NODE_ENV=production rollup -c rollup.config.js

# Or branch name:
GIT_BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
```

`package.json`
```bash
{
  "scripts": {
    "dev": "yarn watch:spa",
    "build": "GIT_SHA1=$(git show --format=\"%h\" --no-patch) NODE_ENV=production rollup -c rollup.config.js",
    "watch": "GIT_SHA1=$(git show --format=\"%h\" --no-patch) NODE_ENV=development OPEN_SPA=0 rollup -c rollup.config.js --watch",
    "watch:spa": "GIT_SHA1=$(git show --format=\"%h\" --no-patch) NODE_ENV=development OPEN_SPA=1 rollup -c rollup.config.js --watch",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
}
```

`./rollup.config.js`
```js
import { writeStaticFileAsync } from './scripts/write_static_file_async'

const gitSHA1 = process.env.GIT_SHA1 || 'No process.env.GIT_SHA1'
const buildInfoFilePath = path.join(__dirname, 'front/static/js/common/constants/build-info.js')
writeStaticFileAsync(buildInfoFilePath, `const gitSHA1 = '${gitSHA1}';`)
```

`./scripts/write_static_file_async.js`
```js
import fs from 'fs'

export const writeStaticFileAsync = (storageFilePath, text) => {
  fs.writeFile(storageFilePath, text, 'utf8', (err) => {
    if (!!err) console.log(err)
  })
}
```

Не забудьте добавить создаваемый файл в `.gitignore`

#git #bash | Get commit hash for build // GIT_SHA1 #smartpriceRINGEO

Из любой ветки?

```bash
git tag sp6
git push origin tags/sp6
```

#git | Tags #smartprice

## Etc.

- [CodeDoc](https://codedoc.cc/)
- [NextBook](https://next-book.vercel.app/intro/index)
- [Docusaurus](https://docusaurus.io/docs)
  - [Demo](https://docusaurus.io/docs/playground)
- [Herodocus](https://github.com/alaskanpuffin/herodotus-core)
  - [Demo](https://www.youtube.com/watch?v=7BvKh9GpGXk)
- [Ingite](https://intuit.github.io/Ignite/pages/IgnitePlugins.html)
- [Presidium](http://presidium.spandigital.net/)
- [Retype](https://retype.com)

#gitbook alternatives

```bash
sudo apt install diffstat
```

```bash
git diff master..bugfix/IT-2258 | diffstat
 main/templates/desktop/trade_in/index.html |   17 ++++++++---
 static/css/tradein/index.css               |    2 -
 static/js/tradein/index_new.js             |   81 +++++++++++++++++++++++++++++++++++++++++-------------
 3 files changed, 75 insertions(+), 25 deletions(-)
```

#git | diffstat #utils список измененных файлов между ветками

```bash
# подскажи, я правильно понял, команда 

git revert <COMMIT_SHA>

# , где COMMIT_SHA - это именно тот коммит, который надо откатить? Просто когда откатываю второй - начинаются проблемы
```

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

с ревертом мержов вообще все непросто)

после этого можешь заново закоммитить, в сокращённом составе файлов (только js и html по задаче)

поидее, должно получиться.

по сути, можешь сделать локально checkout на коммит, где все сделано, скопировать файлы, затем сделать checkout на новый тест, скопировать файлы обратно — и получить вновь свои правки, и их уже коммитить.

(как вариант)

либо ты можешь сделать

```
git checkout <commit> <file>
```

и он достанет файл по состоянию на коммит, как если бы ты его скопировал и сделал add

#git | revert

http://borakpetr.cz/blog/git-for-total-beginners?lang=en

#git console for beginners

https://ru.hexlet.io/courses/intro_to_git/lessons/commits-cancelation/theory_unit

*Если не заливали во внешний репозиторий, можо отменить последний локальный коммит:*
```bash
# Отмена последнего локального коммита
git reset HEAD~
```

#git | Отмена коммитов #hexlet

[Настройка CI/CD для Gitlab-репозитория: схемы и гайд по шагам](https://habr.com/ru/articles/764568/)

Gitlab CI/CD

https://stackoverflow.com/questions/9960897/why-doesnt-my-ssh-key-work-for-connecting-to-github

#github auth #ssh key doesnt work

```bash
git diff 22def05938635578fe65842cbeddc9d211903161 78e15650b709ba85f434d41bed1b79299a3e7138
```

#git | diff Разница между двумя коммитами

#git простым языком

https://www.youtube.com/watch?v=XoBc1ty3m40

#git | soft hard

https://docs.strapi.guru/deploy-guides/do/do-intro

https://github.com/derrickmehaffy/strapi-digitalocean-deploy

#strapi | Digital Ocean deploy sample

```bash
git diff | patch -R -p1
```

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

#git patch | отмена локальных правок

https://www.freecodecamp.org/news/git-checkout-remote-branch-tutorial/

#git | Git Checkout Remote Branch Tutorial

<YoutubePlayer videoId='DiGkq_oobYk' />

## [В чем различие меджу merge & rebase](https://youtu.be/lrdaRbJctaA?t=4825)

<YoutubeGrid json='["d5rvy5XPyzk"]' />

#git | Merge or Rebase ?

https://codeburst.io/understanding-git-hooks-in-the-easiest-way-bad9afcbb1b3

# OLD [2020-06-12]

## Write task name to commit msg

Need to install the following deps:
```bash
yarn add -D husky
```

Need to make `scripts/write-task-name-to-commit.js`:
```js
#!/usr/bin/env node

const fs = require('fs')
const child_process = require('child_process')
const { promisify } = require('util')
const { EOL } = require('os')

const exec = promisify(child_process.exec)
const timeToWrite = 5000
const branchContract = /^(feature|bugfix)\/(CONTRACT)-[0-9]{1,4}/
const taskContract = /(CONTRACT)-[0-9]{1,4}/
const commitEditmsgFile = process.env.HUSKY_GIT_PARAMS || process.argv[2] // file '.git/COMMIT_EDITMSG'

cleanup()
main()

async function getCurrentBranch() {
  const branchOutput = await exec('git symbolic-ref --short HEAD')
  if (branchOutput.stderr) {
    throw new Error(stderr)
  }
  return branchOutput.stdout
}

function getTaskFromBranch(branchName) {
  if (!branchContract.test(branchName)) {
    console.log('⚠️ Имя ветки не соответствует шаблону "{type}/(CONTRACT)-{number}"')
    throw new Error('Unsupported branch name')
  }
  const [, task] = branchName.split('/')
  return task.replace(/\s+/g, '')
}

function existTaskInFile(file) {
  const message = fs.readFileSync(file, 'utf8')
  const withoutComments = message
    .split(EOL)
    .filter((l) => !/^#/.test(l))
    .join('')
  return taskContract.test(withoutComments)
}

function writeTaskToTitleInFile(task, file) {
  const message = fs.readFileSync(file, 'utf8')
  const lines = message.split(EOL)
  lines[0] = `${task} ${lines[0]}`
  const newLines = lines.join(EOL)
  fs.writeFileSync(file, newLines, 'utf8')
}

function cleanup() {
  setTimeout(() => {
    console.log('⚠️ Таймаут commit-msg hook ', timeToWrite)
    process.exit(1)
  }, timeToWrite)
}

async function main() {
  let task = ''
  let branchName = ''
  if (existTaskInFile(commitEditmsgFile)) {
    console.log('👌 В commit сообщении уже есть id задачи')
    process.exit(0)
  }
  try {
    branchName = await getCurrentBranch()
    task = getTaskFromBranch(branchName)
  } catch (error) {
    console.log('⚠️ Не удалось получить имя задачи', task, 'из ветки', branchName)
    process.exit(1)
  }
  try {
    writeTaskToTitleInFile(task, commitEditmsgFile)
  } catch (err) {
    console.log('⚠️ Не удалось записать имя задачи', task, 'в commit-msg файл', commitEditmsgFile)
    console.error(err)
    process.exit(1)
  }

  console.log('👌 Перезапись сообщения коммита: УСПЕШНО')
  process.exit(0)
}
```

As you can see my pattern is `/^(feature|bugfix)\/(CONTRACT)-[0-9]{1,4}/`. Next changes in `package.json` should be like this:
```js
{
  "husky": {
    "hooks": {
      "commit-msg": "node ./scripts/write-task-name-to-commit"
    }
  },
}
```

That's all. Task name should be added for next commit automatically.

## Pre commit

Need to install the following deps:
```bash
# Our target deps:
yarn add -D prettier lint-staged

# Install this if necessary:
yarn add -D typescript eslint-config-prettier eslint-plugin-prettier@latest eslint-plugin-standard
```

Next changes in `package.json` should be like this:
```js
{
  "lint-staged": {
    "*.{js, jsx, ts, tsx}": [
    // For storybook:
    // "*.{js, jsx, ts, tsx} !.storybook/*": [
      "node_modules/.bin/eslint --max-warnings=0",
      "prettier --write"
    ]
  },
  "husky": {
    "hooks": {
      "pre-commit": "lint-staged"
    }
  },
}
```

And also you could make this updates in `package.json` if interested:
```js
{
  "scripts": {
    // ...
    "lint": "eslint --debug src/**/*.js*",
    "lint:fix": "eslint src/**/*.ts* --fix"
  }
}
```
Congrats! The next commit will have your `pre-commit` hook.

## P.S.

На всякий случай, проверил, все ли работает если следовать по данной инструкции. Посмотреть можно [здесь](https://github.com/pravosleva/git-hooks-samples).

#git hooks

https://github.com/gitname/react-gh-pages#procedure

#github pages

#githubAPI

```bash
# Delete remote branch
git push origin :test
To gitlab.com:smartprice/ringeo-crm-front.git
 - [deleted]             test
```

> [Delete a local and a remote GIT branch](https://koukia.ca/delete-a-local-and-a-remote-git-branch-61df0b10d323)

[How do I delete a Git branch locally and remotely?](https://stackoverflow.com/questions/2003505/how-do-i-delete-a-git-branch-locally-and-remotely)

# Delete local brach
```bash
git branch -d test
error: Ветка «test» не слита полностью.
Если вы уверены, что хотите ее удалить, запустите «git branch -D test».
```

#git | remove branch

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

```js
var cp = require('child_process');
var priv;

var USER = process.env.GITHUB_USERNAME || 'YOUR_GITHUB_USERNAME';

module.exports = {

  name: prompt('name', basename || package.name),

  version: '0.0.1',

  private: prompt('private', 'true', function(val) {
    return priv = (typeof val === 'boolean') ? val : !!val.match('true')
  }),

  create: prompt('create github repo', 'yes', function(val) {
    val = val.indexOf('y') !== -1 ? true : false;

    if (val) {
      console.log('enter github password:');
      cp.execSync("curl -u '" + USER + "' https://api.github.com/user/repos -d " +
        "'{\"name\": \"" + basename + "\", \"private\": " + ((priv) ? 'true' : 'false') + "}' ");
      cp.execSync('git remote add origin ' + 'https://github.com/' + USER + '/' + basename + '.git');
    }

    return undefined;
  }),

  main: prompt('entry point', 'index.js'),

  repository: {
    type: 'git',
    url: 'git://github.com/' + USER + '/' + basename + '.git'
  },

  bugs: {
    url: 'https://github.com/' + USER '/' + basename + '/issues'
  },

  homepage: "https://github.com/" + USER + "/" + basename,

  keywords: prompt(function(s) {
    return s.split(/\s+/)
  }),

  license: 'MIT',

  cleanup: function(cb) {

    cb(null, undefined)
  }
}
```

git