Połącz gałąź rozwoju z master

Osobiście, moje podejście jest podobne do twojego, z kilkoma gałęziami i kilkoma zmiażdżeniami commitów, gdy wrócą do mistrza.

Jeden z moich współpracowników nie lubi tak bardzo zmieniać gałęzi i zostaje na gałęzi deweloperskiej z czymś podobnym do poniższych wykonanych z gałęzi deweloperskiej.

git fetch origin master

git merge master

git push origin development:master

Pierwsza linia upewnia się, że posiada wszelkie commity, które zostały wprowadzone do master od czasu ostatniej aktualizacji jego lokalnego repozytorium.

Drugi ciągnie te zmiany (jeśli istnieją) z master do development

Trzeci popycha gałąź programistyczną (teraz w pełni połączoną z master) do origin/master.

Mogę trochę pomylić jego podstawowy obieg pracy, ale to jest główny sedno tego.

Wyjaśnienie z dołu dla tych, którzy przybyli tutaj bez wiedzy o gałęziach.

Podstawowa logika rozwoju gałęzi master brzmi: pracujesz tylko na innych gałęziach i używasz master tylko do scalania innych gałęzi.

Zaczynasz tworzyć nową gałąź w ten sposób:

Sklonuj repozytorium w lokalnym katalogu (lub utwórz nowe repozytorium):

$ cd /var/www
$ git clone [email protected]:user_name/repository_name.git

1. Utwórz nową gałąź. Będzie zawierać najnowsze pliki Twojej gałęzi master repozytorium

$ git branch new_branch

1. Zmień bieżącą gałąź git na new_branch

$ git checkout new_branch

1. czy kodowanie, commity, jak zwykle ...

$ git add .
$ git commit -m “Initial commit”
$ git push # pushes commits only to “new_branch”

1. kiedy zadanie zostanie zakończone na tej gałęzi, połącz się z gałęzią "master":

$ git merge master
$ git checkout master # goes to master branch
$ git merge development # merges files in localhost. Master shouldn’t have any  commits ahead, otherwise there will be a need for pull and merging code by hands!
$ git push # pushes all “new_branch” commits to both branches - “master” and “new_branch”

Polecam również korzystanie z aplikacji Sourcetree, aby zobaczyć wizualne drzewo zmian i gałęzi.

1. //pull the latest changes of current development branch if any        
git pull (current development branch)

2. //switch to master branch
git checkout master 

3. //pull all the changes if any
git pull

4. //Now merge development into master    
git merge development

5. //push the master branch
git push origin master

Byłoby świetnie, gdybyś mógł użyć Git Flow workflow. Może łatwo połączyć rozwijaną gałąź w master.

To co chcesz zrobić, to po prostu postępować zgodnie z instrukcją git-flow wspomnianą tutaj:

Kroki:

• setup the Git-flow project
• twórz gałęzie i łącz wszystko z rozwijaj
• uruchom polecenie git flow release start <version_number>
• następnie podaj sensowną wiadomość dla Wydania
• uruchom polecenie git flow release finish <version_number>
• połączy wszystko w master i zmieni gałąź na master .
• uruchom polecenie git push, aby opublikować zmiany w zdalnym master .

Aby uzyskać więcej informacji, odwiedź Stronę - http://danielkummer.github.io/git-flow-cheatsheet/

Tak, to prawda, ale wygląda to na bardzo podstawowy przepływ pracy, w którym buforujesz zmiany, zanim będą gotowe do integracji. Powinieneś przyjrzeć się bardziej zaawansowanym przepływom pracy , które obsługuje git. Może Ci się spodobać gałąź tematyczna , która pozwala pracować jednocześnie nad wieloma funkcjami, lub podejście stopniowe , które nieco wydłuża bieżący przepływ pracy.

Jeśli korzystasz z systemu Mac lub Ubuntu, przejdź do folderu roboczego gałęzi. W terminalu

Przypuśćmy, że harisdev jest branchname.

git checkout master

Jeśli są pliki, które nie są śledzone lub niezakontraktowane, pojawi się błąd i musisz zatwierdzić lub usunąć wszystkie pliki, które nie są śledzone lub niezakontraktowane.

git merge harisdev 

git push origin master

Ostatnie polecenie do usunięcia gałęzi.

$ git branch -d harisdev

Krok 1

Utwórz i przełącz się na nową gałąź "dev", gdzie lokalne pliki git są zsynchronizowane ze zdalną, ale gałąź" dev " jeszcze nie istnieje.

git branch dev # create
git checkout dev # switch
# No need to git add or git commit, the current
# branch's files will be cloned to the new branch by-default.
git push --set-upstream origin dev # push the "dev" branch to the remote.

Krok 2

Dokonaj zmian w gałęzi" dev "(bieżąca jeśli wykonasz Krok 1), Zatwierdź i wypchnij je do zdalnej gałęzi" dev".

git add .
git commit -S -m "my first commit to the dev branch" # remove the -S if you're not "secure", secure = when you already setup crypto private and public keys (i.e "verified" green sign in github)
git push -u origin dev # push the changes to the remote, -u origin dev is optional but good to use.

Krok 3

Połącz swoją gałąź " dev " z "master".

git checkout dev # switch to "dev" branch if you're not already.
git merge master # optionally, this command is being used to resolve any conflicts if you pushed any changes to your "master" but "dev" doesn't have that commit.
git checkout master # switch to "master", which is the branch you want to be merged.
git merge --no-ff dev # merge the "dev" branch into the "master" one.

Tak zwykle to robię. Po pierwsze, upewnij się, że jesteś gotowy do scalenia zmian w master.

1. sprawdź, czy rozwój jest na bieżąco z najnowszymi zmianami z serwera zdalnego za pomocą git fetch
2. Po zakończeniu pobierania git checkout master.
3. upewnij się, że gałąź master posiada najnowsze aktualizacje wykonując git pull
4. Po zakończeniu przygotowań można rozpocząć połączenie z git merge development
5. wciśnij zmiany za pomocą git push -u origin master i będziesz załatwione.

Więcej informacji na temat Git merging znajdziesz w artykule.

Na podstawie @ Sailesh i @DavidCulp:

(on branch development)
$ git fetch origin master
$ git merge FETCH_HEAD
(resolve any merge conflicts if there are any)
$ git checkout master
$ git merge --no-ff development (there won't be any conflicts now)

Pierwsze polecenie upewni się, że wszystkie commity wysyłane do remote master, z odpowiedzią Sailesh, która by się nie zdarzyła.

Drugi wykona scalenie i stworzy konflikty, które można następnie rozwiązać.

Po tym, można w końcu checkout master, aby przełączyć się na master.

Następnie łączysz gałąź rozwoju z lokalnym master. Flaga no - FF utworzy węzeł commit w master dla całej Połącz, aby można było śledzić.

Następnie możesz zatwierdzić i przesunąć połączenie.

Ta procedura upewni się, że istnieje commit merge od development do master, który ludzie mogą zobaczyć, a następnie, jeśli przejrzą gałąź development, zobaczą poszczególne commity, które wprowadziłeś do tej gałęzi podczas jej tworzenia.

Opcjonalnie możesz zmienić swój commit scalający, zanim go wypchniesz, jeśli chcesz dodać podsumowanie tego, co zostało zrobione w gałęzi deweloperskiej.

EDIT: mój oryginalna odpowiedź sugerowała git merge master, która nic nie zrobiła, lepiej zrobić git merge FETCH_HEAD Po pobraniu origin / master

1) Podczas tworzenia gałęzi sprawdź status git używając następującego polecenia:

git status

Nie powinno być niezakontraktowanego kodu. Jeśli tak, to wypchnij kod na gałęzi deweloperskiej:

git add *

git commit -m "My initial commit message"

git push origin Development

2) w gałęzi deweloperskiej uruchom następujące dwa polecenia:

git branch -f master HEAD

git push -f origin master

Spowoduje przesunięcie kodu gałęzi deweloperskiej do gałęzi master.

Po "kasie" gałąź rozwoju Ciebie ...

 git add .
 git commit -m "first commit"
 git push origin dev
 git merge master

 git checkout master 
 git merge dev
 git push origin master 

Jeśli używasz gerrit, poniższe polecenia działają idealnie.

git checkout master
git merge --no-ff development

Możesz zapisać za pomocą domyślnego komunikatu zatwierdzającego. Upewnij się, że identyfikator zmiany został wygenerowany. Możesz użyć następującego polecenia, aby się upewnić.

git commit --amend

Następnie wciśnij następujące polecenie.

git push origin HEAD:refs/for/refs/heads/master

Możesz napotkać komunikat o błędzie, taki jak poniżej.

! [remote rejected] HEAD -> refs/for/refs/heads/master (you are not allowed to upload merges)

Aby rozwiązać ten problem, administrator projektu gerrit musi utworzyć w gerrit inne odniesienie o nazwie "refs/for / refs / heads / master" lub "refs / for / refs / heads / * "(które obejmie wszystkie oddziały w przyszłości). Następnie przyznaj uprawnienia "Push Merge Commit" do tego odniesienia i "Submit", jeśli jest to wymagane do przesłania GCR.

Spróbuj jeszcze raz powyższą komendę push i powinno zadziałać.

Napisy:

Https://github.com/ReviewAssistant/reviewassistant/wiki/Merging-branches-in-Gerrit

Https://stackoverflow.com/a/21199818/3877642

Myślę, że najprostszym rozwiązaniem byłoby

git checkout master
git remote update
git merge origin/Develop -X theirs
git commit -m commit -m "New release"
git push --recurse-submodules=check --progress "origin" refs/heads/Master

To również zachowuje historię wszystkich gałęzi w użyciu

1. //push the latest changes of current development branch if any        
git push (current development branch)

2. //switch to master branch
git checkout master 

3. //pull all the changes if any from (current development branch)
git pull origin (current development branch)

4. //Now merge development into master    
git merge development

5. //push the master branch
git push origin master

Error
To https://github.com/rajputankit22/todos-posts.git
 ! [rejected]        master -> master (fetch first)
error: failed to push some refs to 'https://github.com/rajputankit22/todos-posts.git'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. This is usually caused by another repository pushing
hint: to the same ref. You may want to first integrate the remote changes
hint: (e.g., 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Then Use 
5. //push the master branch forcefully
git push -f origin master