Chcę móc wykonać następujące czynności:

1. Utwórz oddział lokalny na podstawie innego (zdalnego lub lokalnego) oddziału (przez git branchlub git checkout -b)

2. Wciśnij oddział lokalny do zdalnego repozytorium (publikuj), ale spraw, aby można go było śledzić git pulli git pushbędzie działać natychmiast.

Jak mogę to zrobić?

Wiem o tym --set-upstreamw Git 1.7, ale jest to akcja po stworzeniu. Chcę znaleźć sposób na dokonanie podobnej zmiany podczas wypychania gałęzi do zdalnego repozytorium.

W Git 1.7.0 i nowszych możesz pobrać nową gałąź:

git checkout -b <branch>

Edytuj pliki, dodawaj i zatwierdzaj. Następnie naciśnij-u--set-upstream opcję (skrót od ) :

git push -u origin <branch>

Git skonfiguruje informacje o śledzeniu podczas wypychania.

Jeśli nie udostępniasz repozytorium innym osobom, przydatne jest wypchnięcie wszystkich gałęzi do pilota i --set-upstreamprawidłowe śledzenie:

git push --all -u

(Nie do końca to, o co prosił PO, ale ten jednowarstwowy jest dość popularny)

Jeśli dzielisz się repozytorium z innymi, nie jest to naprawdę dobra forma, ponieważ zapchasz repo wszystkimi swoimi podejrzanymi gałęziami eksperymentalnymi.

Przed wprowadzeniem git push -unie było git pushmożliwości uzyskania tego, czego pragniesz. Trzeba było dodać nowe instrukcje konfiguracji.

Jeśli utworzysz nowy oddział za pomocą:

$ git checkout -b branchB
$ git push origin branchB:branchB

Możesz użyć git configpolecenia, aby uniknąć bezpośredniej edycji .git/configpliku.

$ git config branch.branchB.remote origin
$ git config branch.branchB.merge refs/heads/branchB

Możesz też ręcznie edytować .git/configplik, aby mieć informacje o śledzeniu do tej gałęzi.

[branch "branchB"]
    remote = origin
    merge = refs/heads/branchB

Mówiąc prosto, aby utworzyć nowy oddział lokalny , wykonaj:

git branch <branch-name>

Aby przekazać go do zdalnego repozytorium, wykonaj:

git push -u origin <branch-name>

Niewielka różnorodność podanych tutaj rozwiązań:

1. Utwórz oddział lokalny na podstawie innego (zdalnego lub lokalnego) oddziału:

   git checkout -b branchname
   

2. Wciśnij oddział lokalny do zdalnego repozytorium (publikuj), ale spraw, aby można go było śledzić git pulli git pushbędzie działać natychmiast

   git push -u origin HEAD
   

   Użycie HEADto „wygodny sposób na przesunięcie bieżącej gałęzi do tej samej nazwy na pilocie”. Źródło: https://git-scm.com/docs/git-push W terminologii Git HEAD (wielkimi literami) jest odniesieniem do górnej części bieżącej gałęzi (drzewa).

   Ta -uopcja jest po prostu krótka --set-upstream. Spowoduje to dodanie referencji śledzenia w górę dla bieżącej gałęzi. możesz to sprawdzić, przeglądając plik .git / config:

   

Po prostu robię

git push -u origin localBranch:remoteBranchToBeCreated

nad już sklonowanym projektem.

Git tworzy nowy oddział o nazwie remoteBranchToBeCreatedpod moimi zobowiązaniami, które zrobiłem localBranch.

Edycja : zmienia bieżący oddział lokalny (ewentualnie nazwany localBranch) w górę origin/remoteBranchToBeCreated. Aby to naprawić, po prostu wpisz:

git branch --set-upstream-to=origin/localBranch

Więc twój obecny oddział lokalny śledzi teraz origin/localBranch.

Przypuszczam, że już sklonowałeś projekt taki jak:

git clone http://github.com/myproject.git

1. Następnie w lokalnej kopii utwórz nowy oddział i sprawdź go:

   git checkout -b <newbranch>
   

2. Załóżmy, że utworzyłeś „git bare --init” na swoim serwerze i utworzyłeś myapp.git, powinieneś:

   git remote add origin ssh://example.com/var/git/myapp.git
   git push origin master
   

3. Następnie użytkownicy powinni mieć możliwość

   git clone http://example.com/var/git/myapp.git
   

UWAGA: Zakładam, że masz uruchomiony serwer. Jeśli nie jest, nie będzie działać. Dobre instrukcje są tutaj .

DODANY

Dodaj zdalną gałąź:

git push origin master:new_feature_name

Sprawdź, czy wszystko jest w porządku (pobierz źródło i zdalne gałęzie):

git fetch origin
git branch -r

Utwórz oddział lokalny i śledź oddział zdalny:

git checkout -tb new_feature_name origin/new_feature_name

Zaktualizuj wszystko:

git pull

edytuj Nieaktualne, po prostu użyjgit push -u origin $BRANCHNAME

Skorzystaj git publish-branchz różnych narzędzi Git Williama ( genialne repo i klonowanie ).

OK, nie Ruby, więc - ignorując zabezpieczenia! - weź trzy ostatnie wiersze skryptu i utwórz skrypt bash git-publish-branch:

#!/bin/bash
REMOTE=$1 # Rewrite this to make it optional...
BRANCH=$2
# Uncomment the following line to create BRANCH locally first
#git checkout -b ${BRANCH}
git push ${ORIGIN} ${BRANCH}:refs/heads/${BRANCH} &&
git config branch.${BRANCH}.remote ${REMOTE} &&
git config branch.${BRANCH}.merge refs/heads/${BRANCH}

Następnie uruchom git-publish-branch REMOTENAME BRANCHNAME, gdzie REMOTENAME to zazwyczaj origin (możesz zmodyfikować skrypt, aby przyjmował pochodzenie jako domyślny itp.)

Aby utworzyć nowy oddział poprzez rozgałęzienie z istniejącego oddziału

git checkout -b <new_branch>

a następnie wypchnij ten nowy oddział do repozytorium za pomocą

git push -u origin <new_branch>

Spowoduje to utworzenie i przekazanie wszystkich zatwierdzeń lokalnych do nowo utworzonego zdalnego oddziału origin/<new_branch>

W przypadku wersji GitLab wcześniejszej niż 1.7 użyj:

git checkout -b name_branch

(name_branch, ex: master)

Aby przekazać go do zdalnego repozytorium, wykonaj:

git push -u origin name_new_branch

(name_new_branch, na przykład: feature)

Utworzyłem alias, aby za każdym razem, gdy utworzyłem nowy oddział, odpowiednio go popychał i śledził. Do .bash_profilepliku wstawiłem następujący fragment :

# Create a new branch, push to origin and track that remote branch
publishBranch() {
  git checkout -b $1
  git push -u origin $1
}
alias gcb=publishBranch

Zastosowanie : wystarczy wpisać za gcb thuy/do-sth-koolpomocą thuy/do-sth-koolto moja nowa nazwa oddziału.

Opierając się nieco na odpowiedziach tutaj, podsumowałem ten proces jako prosty skrypt Bash, który oczywiście może być również używany jako alias Git.

Ważnym dodatkiem do mnie jest to, że zachęca mnie to do przeprowadzenia testów jednostkowych przed zatwierdzeniem i domyślnie podaje aktualną nazwę oddziału.

$ git_push_new_branch.sh

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch           -> Displays prompt reminding you to run unit tests
  git_push_new_branch OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

git_push_new_branch.sh

function show_help()
{
  IT=$(cat <<EOF

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch.sh           -> Displays prompt reminding you to run unit tests
  git_push_new_branch.sh OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch.sh MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

  )
  echo "$IT"
  exit
}

if [ -z "$1" ]
then
  show_help
fi

CURR_BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$1" == "OK" ]
then
  BRANCH=$CURR_BRANCH
else
  BRANCH=${1:-$CURR_BRANCH}
fi

git push -u origin $BRANCH

Możesz to zrobić w 2 krokach:

1. Użyj checkoutdo utworzenia lokalnego oddziału:

git checkout -b yourBranchName

Pracuj ze swoim Oddziałem, jak chcesz.

2. Użyj pushpolecenia, aby automatycznie utworzyć gałąź i wysłać kod do zdalnego repozytorium:

git push -u origin yourBanchName

Są różne sposoby na zrobienie tego, ale myślę, że ten sposób jest naprawdę prosty.

Aby uzyskać największą elastyczność, możesz użyć niestandardowego polecenia Git . Na przykład utwórz następujący skrypt w języku Python gdzieś $PATHpod nazwą git-publishi wykonaj go:

#!/usr/bin/env python3

import argparse
import subprocess
import sys


def publish(args):
    return subprocess.run(['git', 'push', '--set-upstream', args.remote, args.branch]).returncode


def parse_args():
    parser = argparse.ArgumentParser(description='Push and set upstream for a branch')
    parser.add_argument('-r', '--remote', default='origin',
                        help="The remote name (default is 'origin')")
    parser.add_argument('-b', '--branch', help='The branch name (default is whatever HEAD is pointing to)',
                        default='HEAD')
    return parser.parse_args()


def main():
    args = parse_args()
    return publish(args)


if __name__ == '__main__':
    sys.exit(main())

Następnie git publish -hpokaże ci informacje o użyciu:

usage: git-publish [-h] [-r REMOTE] [-b BRANCH]

Push and set upstream for a branch

optional arguments:
  -h, --help            show this help message and exit
  -r REMOTE, --remote REMOTE
                        The remote name (default is 'origin')
  -b BRANCH, --branch BRANCH
                        The branch name (default is whatever HEAD is pointing to)