Управляющее резюме

$ git push -d <remote_name> <branch_name>
$ git branch -d <branch_name>

Обратите внимание, что в большинстве случаев удаленное имя origin. В таком случае вам придется использовать такую ​​команду.

$ git push -d origin <branch_name>

Удалить локальную ветвь

Чтобы удалить локальную ветку, используйте одно из следующих действий:

$ git branch -d branch_name
$ git branch -D branch_name

Примечание. Параметр -d - это псевдоним для --delete, который удаляет ветвь только в том случае, если она уже была полностью объединена с восходящей ветвью. Вы также можете использовать -D, который является псевдонимом для --delete --force, который удаляет ветку независимо от ее объединенного статуса. [Источник: man git-branch]
Также обратите внимание, что git branch -d branch_name завершится ошибкой, если вы в данный момент находитесь в ветке, которую хотите удалить. Сообщение начинается с error: Cannot delete the branch 'branch_name'. Если это так, сначала переключитесь на другую ветку, например: git checkout main.

Удалить удаленную ветку [Обновлено 8 сентября 2017 г.]

Начиная с Git v1.7.0, вы можете удалите удаленную ветку с помощью

$ git push <remote_name> --delete <branch_name>

что может быть легче запомнить, чем

$ git push <remote_name> :<branch_name>

который был добавлен в Git v1.5.0 в удалить удаленную ветку или тег.

Начиная с Git v2.8.0, вы также можете используйте git push с опцией -d в качестве псевдонима для --delete.

Таким образом, версия Git, которую вы установили, будет определять, нужно ли вам использовать более простой или более сложный синтаксис.

Удалить удаленную ветку [Исходный ответ от 5 января 2010 г.]

Из главы 3 Pro Git Скотт Чакон:

Удаление удаленных филиалов

Предположим, вы закончили с удаленной веткой - скажем, вы и ваши соавторы закончили работу над функцией и объединили ее с основной веткой удаленного (или любой другой веткой, в которой находится ваша стабильная строка кода). Вы можете удалить удаленную ветку, используя довольно тупой синтаксис git push [remotename] :[branch]. Если вы хотите удалить ветку server-fix с сервера, выполните следующее:

$ git push origin :serverfix
To [email protected]:schacon/simplegit.git
 - [deleted]         serverfix

Бум. На вашем сервере больше нет веток. Возможно, вы захотите выслушать эту страницу, потому что вам понадобится эта команда, и вы, вероятно, забудете синтаксис. Чтобы запомнить эту команду, можно вспомнить синтаксис git push [remotename] [localbranch]:[remotebranch], который мы рассмотрели немного ранее. Если вы опустите часть [localbranch], вы, по сути, скажете: «Ничего не возьми с моей стороны и сделай это [remotebranch]».

Выдал git push origin: bugfix, и все прекрасно заработало. Скотт Чакон был прав: я хочу собачье ухо эту страницу (или практически собачье ухо отвечая на это в Stack Overflow).

Затем вы должны выполнить это на других машинах

# Fetch changes from all remotes and locally delete 
# remote deleted branches/tags etc
# --prune will do the job :-;
git fetch --all --prune

распространять изменения.

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

Чтобы удалить локальную ветвь со своего компьютера:

git branch -d {the_local_branch} (используйте -D вместо принудительного удаления ветки без проверки объединенного статуса)

Чтобы удалить удаленную ветку с сервера:

git push origin --delete {the_remote_branch}

Ссылка: Git: удалить ветку (локальную или удаленный)

короткие ответы

Если вам нужны более подробные объяснения следующих команд, см. Подробные ответы в следующем разделе.

Удаление удаленной ветки

git push origin --delete <branch>  # Git version 1.7.0 or newer
git push origin -d <branch>        # Shorter version (Git 1.7.0 or newer)
git push origin :<branch>          # Git versions older than 1.7.0

Удаление локального филиала

git branch --delete <branch>
git branch -d <branch> # Shorter version
git branch -D <branch> # Force-delete un-merged branches

Удаление локальной ветки удаленного отслеживания

git branch --delete --remotes <remote>/<branch>
git branch -dr <remote>/<branch> # Shorter

git fetch <remote> --prune # Delete multiple obsolete remote-tracking branches
git fetch <remote> -p      # Shorter

длинный ответ: нужно удалить три разных ветки!

Когда вы имеете дело с удалением веток как локально, так и удаленно, имейте в виду, что задействованы три разных ветки:

1. Местное отделение X.
2. Ветвь удаленного происхождения X.
3. Локальная ветвь удаленного отслеживания origin/X, которая отслеживает удаленную ветку X.

В оригинальном плакате использовались:

git branch -rd origin/bugfix

При этом была удалена только его локальная ветвь удаленного отслеживания origin/bugfix, а не фактическая удаленная ветка bugfix на origin.

Чтобы удалить эту удаленную ветку, вам потребуется

git push origin --delete bugfix

Дополнительные детали

В следующих разделах описываются дополнительные сведения, которые следует учитывать при удалении веток удаленного и удаленного отслеживания.

Нажатие на удаление удаленных веток также удаляет ветки удаленного отслеживания

Обратите внимание, что удаление удаленной ветви X из командной строки с помощью git push также удалит локальную ветвь удаленного отслеживания origin/X, поэтому нет необходимости обрезать устаревшую ветвь удаленного отслеживания с помощью git fetch --prune или git fetch -p. Впрочем, это не повредит, если вы все равно это сделаете.

Вы можете убедиться, что ветка удаленного отслеживания origin/X также была удалена, выполнив следующее:

# View just remote-tracking branches
git branch --remotes
git branch -r

# View both strictly local as well as remote-tracking branches
git branch --all
git branch -a

Удаление устаревшего локального источника ветки удаленного отслеживания / X

Если вы не удалили удаленную ветку X из командной строки (как указано выше), то ваш локальный репозиторий по-прежнему будет содержать (теперь уже устаревшую) ветку удаленного отслеживания origin/X. Это может произойти, например, если вы удалили удаленную ветку напрямую через веб-интерфейс GitHub.

Типичный способ удалить эти устаревшие ветки удаленного отслеживания (начиная с Git версии 1.6.6) - просто запустить git fetch с --prune или короче -p. Обратите внимание, что при этом удаляются все устаревшие локальные ветки удаленного отслеживания для всех удаленных ветвей, которые больше не существуют на удаленном компьютере:

git fetch origin --prune
git fetch origin -p # Shorter

Вот соответствующая цитата из Примечания к выпуску 1.6.6 (выделено мной):

"git fetch" изучил --all и --multipleoptions для запуска выборки из многих репозиториев и --prune параметр для удаления ветвей удаленного отслеживания, которые устарели. Они делают "git remote update" и "git remote prune" менее необходим (однако нет плана удалять "удаленное обновление" или "удаленное удаление").

Альтернатива вышеуказанной автоматической обрезке для устаревших веток удаленного отслеживания

В качестве альтернативы, вместо удаления устаревших локальных ветвей удаленного отслеживания с помощью git fetch -p, вы можете избежать дополнительных сетевых операций, просто вручную удалив ветки с помощью флагов --remote или -r:

git branch --delete --remotes origin/X
git branch -dr origin/X # Shorter

Смотрите также

• git-branch (1) Страница руководства.
• git-fetch (1) Страница руководства.
• Pro Git 3.5 Git Branch - Remote Branch.

Шаги по удалению ветки:

Чтобы удалить удаленную ветку:

git push origin --delete <your_branch>

Чтобы удалить локальную ветку, у вас есть три способа:

1: git branch -D <branch_name>

2: git branch --delete --force <branch_name>  # Same as -D

3: git branch --delete  <branch_name>         # Error on unmerge

Объясните: Хорошо, просто объясните, что здесь происходит!

Просто выполните git push origin --delete, чтобы удалить только удаленную ветку, добавьте имя ветки в конце, и это удалит, и отправьте ее на удаленный в в то же время...

Кроме того, git branch -D, которые просто удаляют локальную ветку только! ...

-D означает --delete --force, который удалит ветку, даже если она не слита (принудительное удаление), но вы также можете использовать -d, что означает --delete, который выдает ошибку, соответствующую статусу слияния ветки ...

Я также создаю изображение ниже, чтобы показать шаги:

Вы также можете использовать следующее, чтобы удалить удаленную ветку

git push --delete origin serverfix

Что делает то же самое, что и

git push origin :serverfix

но может быть легче запомнить.

Совет: при удалении веток с помощью

git branch -d <branchname> # Deletes local branch

or

git push origin :<branchname> # Deletes remote branch

удаляются только ссылки. Несмотря на то, что ветка фактически удалена на удаленном компьютере, ссылки на нее все еще существуют в локальных репозиториях членов вашей команды. Это означает, что для других членов команды удаленные ветки все еще видны, когда они делают git branch -a.

Чтобы решить эту проблему, члены вашей команды могут обрезать удаленные ветки с помощью

git remote prune <repository>

Обычно это git remote prune origin.

Если вы хотите удалить ветку, сначала сделайте заказ в ветку, отличную от ветки, которую нужно удалить.

git checkout other_than_branch_to_be_deleted

Удаление локальной ветки:

git branch -D branch_to_be_deleted

Удаление удаленной ветки:

git push origin --delete branch_to_be_deleted

Все очень просто:

Чтобы удалить удаленную ветку

git push -d origin <branch-name>

Or

git push origin :<branch-name>

- Вы также можете удалять теги с этим синтаксисом

Чтобы принудительно удалить локальную ветвь

git branch -D <branch-name>

Примечание. выполните git fetch --all --prune на других машинах после удаления удаленной ветви, чтобы удалить устаревшие ветви отслеживания.

Пример

удалить местную ветку

git branch -D my-local-branch

удалить удаленную ветку

git push origin :my-remote-branch

Удачного кодирования :)

Это просто: просто выполните следующую команду:

Чтобы удалить ветку Git как локально, так и удаленно, сначала удалите локальную ветку с помощью этой команды:

git branch -d example

(Здесь example - название ветки.)

И после этого удалите удаленную ветку с помощью этой команды:

git push origin :example

Другой подход:

git push --prune origin

ПРЕДУПРЕЖДЕНИЕ: удаляются все удаленные ветки, которые не существуют локально. Или, в более широком смысле,

git push --mirror

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

В моих настройках Bash я использую следующее:

alias git-shoot="git push origin --delete"

Тогда вы можете позвонить:

git-shoot branchname

Удалить локально:

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

git branch -d <branch_name>

Чтобы удалить ветку принудительно, используйте -D вместо -d.

git branch -D <branch_name>

Удаленное удаление:

Есть два варианта:

git push origin :branchname

git push origin --delete branchname

Я бы посоветовал вам использовать второй способ, так как он более интуитивно понятен.

Если вы хотите выполнить оба этих шага с помощью одной команды, вы можете создать для нее псевдоним, добавив приведенный ниже код в свой ~/.gitconfig:

[alias]
    rmbranch = "!f(){ git branch -d ${1} && git push origin --delete ${1}; };f"

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

git config --global alias.rmbranch \
'!f(){ git branch -d ${1} && git push origin --delete ${1}; };f'

ПРИМЕЧАНИЕ: при использовании -d (строчная буква d) ветвь будет удалена только в том случае, если она была объединена. Чтобы выполнить удаление, вам нужно будет использовать -D (буква D в верхнем регистре).

С января 2013 года GitHub включил кнопку Удалить ветку рядом с каждой веткой на вашей странице «Ветви».

Соответствующее сообщение в блоге: Создание и удаление веток

Чтобы удалить свою ветку локально и удаленно

• Оформить заказ на главную ветку - git checkout master

• Удалите удаленную ветку - git push origin --delete <branch-name>

• Удалите местное отделение - git branch --delete <branch-name>

Вы также можете сделать это с помощью git remote prune origin

$ git remote prune origin
Pruning origin
URL: [email protected]/yourrepo.git
 * [pruned] origin/some-branchs

Он обрезает и удаляет ветки удаленного отслеживания из git branch -r списка.

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

grb delete branch

Я обнаружил, что также довольно часто использую команды publish и track.

однострочная команда для удаления как локального, так и удаленного:

D=branch-name; git branch -D $D; git push origin :$D

Или добавьте указанный ниже псевдоним в свой ~ / .gitconfig. Использование: git kill branch-name

[alias]
    kill = "!f(){ git branch -D \"$1\";  git push origin --delete \"$1\"; };f"

Удаление ветвей

Предположим, наша работа над контактной формой филиала завершена и мы уже интегрировали ее в мастер. Поскольку он нам больше не нужен, мы можем удалить его (локально):

$ git branch -d contact-form

И для удаления удаленной ветки:

git push origin --delete contact-form

Удалить удаленную ветку

git push origin :<branchname>

Удалить локальную ветку

git branch -D <branchname>

Удалить шаги локальной ветки:

1. оформить заказ в другой филиал
2. удалить местную ветку

Просто скажите:

git branch -d <branch-name>
git push origin :<branch-name>

git push origin --delete <branch Name>

легче запомнить чем

git push origin :branchName

Чтобы удалить локально - (нормально)

git branch -d my_branch

Если ваша ветка находится в процессе перебазирования / слияния и это не было сделано должным образом, это означает, что вы получите сообщение об ошибке Rebase/Merge in progress, поэтому в этом случае вы не сможете удалить свою ветку.

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

git branch -D my_branch

Чтобы удалить на удаленном:

git push --delete origin my_branch

Вы можете сделать то же самое, используя:

git push origin :my_branch   # Easy to remember both will do the same.

Графическое представление:

Теперь это можно сделать с помощью приложения GitHub Desktop.

После запуска приложения

1. Щелкните проект, содержащий ветку

2. Переключитесь на ветку, которую хотите удалить

   

3. В меню «Ветвь» выберите «Отменить публикацию ...», чтобы удалить ветку с серверов GitHub.

   

4. В меню «Ветвь» выберите «Удалить» branch_name «...», чтобы ветка была удалена с вашего локального компьютера (он же машина, на которой вы в настоящее время работаете).

   

Это не сработает, если у вас есть тег с тем же именем, что и ветка на пульте дистанционного управления:

$ git push origin :branch-or-tag-name
error: dst refspec branch-or-tag-name matches more than one.
error: failed to push some refs to '[email protected]:SomeName/some-repo.git'

В этом случае вам нужно указать, что вы хотите удалить ветку, а не тег:

git push origin :refs/heads/branch-or-tag-name

Точно так же, чтобы удалить тег вместо ветки, вы должны использовать:

git push origin :refs/tags/branch-or-tag-name

Многие другие ответы приведут к ошибкам / предупреждениям. Этот подход относительно надежен, хотя вам все равно может понадобиться git branch -D branch_to_delete, если он, например, не полностью объединен с some_other_branch.

git checkout some_other_branch
git push origin :branch_to_delete
git branch -d branch_to_delete

Удаленная обрезка не требуется, если вы удалили удаленную ветку. Он используется только для получения самых последних пультов дистанционного управления, доступных в репозитории, который вы отслеживаете. Я заметил, что git fetch будет добавлять пульты дистанционного управления, а не удалять их. Вот пример того, когда git remote prune origin действительно что-то сделает:

Пользователь А выполняет описанные выше действия. Пользователь B будет запускать следующие команды, чтобы увидеть самые свежие удаленные ветки:

git fetch
git remote prune origin
git branch -r

Мне надоело гуглить этот ответ, поэтому я применил аналогичный подход к ответу, который crizCraig опубликовал ранее.

Я добавил в свой профиль Bash следующее:

function gitdelete(){
    git push origin --delete $1
    git branch -D $1
}

Затем каждый раз, когда я заканчиваю работу с веткой (например, слитая с master), я запускаю в своем терминале следующее:

gitdelete my-branch-name

... который затем удаляет my-branch-name из origin, а также локально.

Перед выполнением

git branch --delete <branch>

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

git ls-remote

Это подскажет вам, что вводить именно для <branch> значения. (branch чувствителен к регистру!)

Использовать:

git push origin :bugfix  # Deletes remote branch
git branch -d bugfix     # Must delete local branch manually

Если вы уверены, что хотите его удалить, запустите

git branch -D bugfix

Теперь, чтобы очистить удаленные удаленные ветки, запустите

git remote prune origin

Согласно последнему документу, используя терминал, мы можем удалить следующим образом.

Удалить на локальном уровне:

git branch -D usermanagement

Удалить в удаленном месте:

git push --delete origin usermanagement

Вот смесь всех остальных ответов. Он требует Ruby 1.9.3+ и протестирован только на OS X.

Назовите этот файл git-remove, сделайте его исполняемым и поместите в свой путь. Тогда используйте, например, git remove temp.

#!/usr/bin/env ruby
require 'io/console'

if __FILE__ == $0
      branch_name = ARGV[0] if (ARGV[0])
      print "Press Y to force delete local and remote branch #{branch_name}..."
    response = STDIN.getch
    if ['Y', 'y', 'yes'].include?(response)
      puts "\nContinuing."
      `git branch -D #{branch_name}`
      `git branch -D -r origin/#{branch_name}`
      `git push origin --delete #{branch_name}`
    else
      puts "\nQuitting."
    end
end

Я добавил в свой .gitconfig файл следующие псевдонимы. Это позволяет мне удалять ветки с указанием имени ветки или без него. Имя ветки по умолчанию используется для текущей ветки, если не передан аргумент.

[alias]
    branch-name = rev-parse --abbrev-ref HEAD     

    rm-remote-branch = !"f() { branch=${1-$(git branch-name)}; git push origin :$branch; }; f"
    rm-local-branch = !"f() { branch=${1-$(git branch-name)}; git checkout master; git branch -d $branch; }; f"
    rm-branch-fully = !"f() { branch=${1-$(git branch-name)}; git rm-local-branch $branch; git rm-remote-branch $branch; }; f"

Альтернативой командной строке для удаления удаленных ветвей является страница веток GitHub.

См., Например: https://github.com/angular/angular.js/branches

Находится на странице Code -> Branches репозитория GitHub.

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

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

branch_not_delete=( "master" "develop" "our-branch-1" "our-branch-2")

for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do

    # Delete prefix remotes/origin/ from branch name
    branch_name="$(awk '{gsub("remotes/origin/", "");print}' <<< $branch)"

    if ! [[ " ${branch_not_delete[*]} " == *" $branch_name "* ]]; then
        # Delete branch remotly and locally
        git push origin :$branch_name
    fi
done

• Перечислите ветки, которые вы не хотите удалять
• Перебирайте ветки пульта ДУ и, если их нет в нашем «списке сохранения», удалите их.

Источник: Немедленное удаление веток Git

Используя Git Bash, вы можете выполнить следующее:

git branch --delete <branch>

Or

-

В настольном приложении GitHub, когда у вас есть ветка, вы можете удалить локальную ветку через полосу меню Branch:

Если вы не настольного приложения GitHub и используете IDE, например Visual Studio, для локального управления исходным кодом, все, что вам нужно сделать, это несколько быстрых шагов:

1. Найдите ветку, отличную от той, которую вы хотите удалить.
2. Щелкните правой кнопкой мыши ветку, которую хотите удалить.
3. В контекстном меню выберите вариант Удалить.

Затем, войдя в свою учетную запись GitHub в Интернете, перейдите в репозиторий и щелкните вкладку Все ветви. Оттуда просто нажмите на маленький значок корзины справа от названия ветки, которую вы хотите удалить.

* Имейте в виду - если ветка не опубликована, не нужно пытаться удалить ее из онлайн-репозитория.

Я создал в своем файле .bash_aliases следующую удобную функцию:

git-delete-branch() 
{ 
    if [[ -n $1 ]]; then
        git checkout master > /dev/null;
        branch_name="$1";
        echo "Deleting local $branch_name branch...";
        git branch -D "$branch_name";
        echo "Deleting remote $branch_name branch...";
        git push origin --delete "$branch_name";
        git remote prune origin;
        echo "Your current branches are:";
        git branch -a;
    else
        echo "Usage: git-delete-branch <branch_name>";
    fi
}

Самый гибкий способ - использовать настраиваемую команду Git. Например, создайте следующий сценарий Python где-нибудь в вашем $PATH под именем git-rmbranch и сделайте его исполняемым:

#!/usr/bin/env python3

import argparse
import subprocess
import sys

def rmbranch(branch_name, remote, force):
    try:
        print(subprocess.run(['git', 'branch', '-D' if force else '-d', branch_name],
                             capture_output=True, check=True, encoding='utf-8').stdout, end='')
    except subprocess.CalledProcessError as exc:
        print(exc.stderr.replace(f'git branch -D {branch_name}', f'git rmbranch -f {branch_name}'), end='')
        return exc.returncode

    return subprocess.run(['git', 'push', remote, '--delete', branch_name]).returncode    

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Delete a Git branch locally and remotely.')
    parser.add_argument('-r', '--remote', default='origin', help="The remote name (defaults to 'origin')")
    parser.add_argument('-f', '--force', action='store_true', help='Force deletion of not fully merged branches')
    parser.add_argument('branch_name', help='The branch name')
    args = parser.parse_args()

    sys.exit(rmbranch(args.branch_name, args.remote, args.force))

Затем git rmbranch -h покажет вам информацию об использовании:

usage: git-rmbranch [-h] [-r REMOTE] [-f] branch_name

Delete a Git branch locally and remotely.

positional arguments:
  branch_name           The branch name

optional arguments:
  -h, --help            show this help message and exit
  -r REMOTE, --remote REMOTE
                        The remote name (defaults to 'origin')
  -f, --force           Force deletion of not fully merged branches

Обратите внимание, что git push origin --delete <branch_name> также удаляет локальную ветвь удаленного отслеживания (origin/<branch_name> по умолчанию), поэтому не нужно об этом заботиться.

P.S. Последнюю версию этой команды Git можно найти здесь. Комментарии и предложения приветствуются.

Первые несколько методов у меня не сработали,

Допустим, у вас есть следующая ветка и удаленная ветка,

Local  : Test_Branch
Remote : remotes/origin/feature/Test_FE

Правильно настройте восходящий поток для вашей локальной ветки, чтобы отслеживать удаленную ветку, которую вы хотите удалить.

git branch --set-upstream-to=remotes/origin/feature/Test_FE Test_Branch

Затем, чтобы удалить удаленную ветку, выполните это

git push origin --delete Test_Branch

Затем, чтобы удалить локальную ветку, выполните следующую команду

git branch -D Test_Branch

Вот и все. Ваше здоровье.

И CoolAJ86, и apenwarr ответы очень похожи. Я ходил туда-сюда, пытаясь понять лучший подход для поддержки замены подмодуля. Ниже представлена ​​их комбинация.

Сначала перейдите Git Bash в корень репозитория Git, который нужно разделить. В моем примере это ~/Documents/OriginalRepo (master)

# Move the folder at prefix to a new branch
git subtree split --prefix=SubFolderName/FolderToBeNewRepo --branch=to-be-new-repo

# Create a new repository out of the newly made branch
mkdir ~/Documents/NewRepo
pushd ~/Documents/NewRepo
git init
git pull ~/Documents/OriginalRepo to-be-new-repo

# Upload the new repository to a place that should be referenced for submodules
git remote add origin [email protected]:myUsername/newRepo.git
git push -u origin master
popd

# Replace the folder with a submodule
git rm -rf ./SubFolderName/FolderToBeNewRepo
git submodule add [email protected]:myUsername/newRepo.git SubFolderName/FolderToBeNewRepo
git branch --delete --force to-be-new-repo

Ниже приведена копия вышеизложенного с замененными настраиваемыми именами и использованием вместо этого HTTPS. Корневая папка теперь ~/Documents/_Shawn/UnityProjects/SoProject (master)

# Move the folder at prefix to a new branch
git subtree split --prefix=Assets/SoArchitecture --branch=so-package

# Create a new repository out of the newly made branch
mkdir ~/Documents/_Shawn/UnityProjects/SoArchitecture
pushd ~/Documents/_Shawn/UnityProjects/SoArchitecture
git init
git pull ~/Documents/_Shawn/UnityProjects/SoProject so-package

# Upload the new repository to a place that should be referenced for submodules
git remote add origin https://github.com/Feddas/SoArchitecture.git
git push -u origin master
popd

# Replace the folder with a submodule
git rm -rf ./Assets/SoArchitecture
git submodule add https://github.com/Feddas/SoArchitecture.git
git branch --delete --force so-package