Ich möchte Folgendes tun können:

1. Erstellen Sie einen lokalen Zweig basierend auf einem anderen (entfernten oder lokalen) Zweig (über git branchoder git checkout -b).

2. Schieben Sie den lokalen Zweig in das Remote-Repository (veröffentlichen), machen Sie ihn jedoch nachverfolgbar git pullund git pushfunktionieren Sie sofort.

Wie mache ich das?

Ich weiß über --set-upstreamGit 1.7 Bescheid , aber das ist eine Aktion nach der Erstellung. Ich möchte einen Weg finden, eine ähnliche Änderung vorzunehmen, wenn der Zweig in das Remote-Repository verschoben wird.

In Git 1.7.0 und höher können Sie einen neuen Zweig auschecken:

git checkout -b <branch>

Dateien bearbeiten, hinzufügen und festschreiben. Dann drücken Sie mit dem -u(kurz für --set-upstream) Option:

git push -u origin <branch>

Git richtet die Tracking-Informationen während des Pushs ein.

Wenn Sie Ihr Repo nicht mit anderen teilen, ist dies hilfreich, um alle Ihre Filialen auf die Fernbedienung zu übertragen und --set-upstreamfür Sie korrekt zu verfolgen:

git push --all -u

(Nicht genau das, wonach das OP gefragt hat, aber dieser Einzeiler ist ziemlich beliebt)

Wenn Sie Ihr Repo mit anderen teilen, ist dies keine wirklich gute Form, da Sie das Repo mit all Ihren zwielichtigen experimentellen Zweigen verstopfen werden.

Vor der Einführung von git push -ugab es keine git pushMöglichkeit, das zu erhalten, was Sie wünschen. Sie mussten neue Konfigurationsanweisungen hinzufügen.

Wenn Sie einen neuen Zweig erstellen mit:

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

Mit dem git configBefehl können Sie vermeiden, das direkt zu bearbeiten.git/config Datei .

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

Sie können die .git/configDatei auch manuell bearbeiten, um Tracking-Informationen für diesen Zweig zu erhalten.

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

Einfach ausgedrückt, um eine neue lokale Niederlassung zu erstellen , gehen Sie wie folgt vor:

git branch <branch-name>

Gehen Sie folgendermaßen vor, um es in das Remote- Repository zu übertragen:

git push -u origin <branch-name>

Eine kleine Variation der hier bereits angegebenen Lösungen:

1. Erstellen Sie einen lokalen Zweig basierend auf einem anderen (entfernten oder lokalen) Zweig:

   git checkout -b branchname
   

2. Schieben Sie den lokalen Zweig in das Remote-Repository (veröffentlichen), machen Sie ihn jedoch nachverfolgbar git pullund git pushfunktionieren Sie sofort

   git push -u origin HEAD
   

   Die Verwendung HEADist eine "praktische Möglichkeit, den aktuellen Zweig auf der Fernbedienung auf denselben Namen zu verschieben". Quelle: https://git-scm.com/docs/git-push In Git-Begriffen ist HEAD (in Großbuchstaben) ein Verweis auf den oberen Rand des aktuellen Zweigs (Baums).

   Die -uOption ist nur kurz für --set-upstream. Dadurch wird eine Upstream-Tracking-Referenz für den aktuellen Zweig hinzugefügt. Sie können dies überprüfen, indem Sie in Ihrer .git / config-Datei nachsehen:

   

Ich mache es einfach

git push -u origin localBranch:remoteBranchToBeCreated

über ein bereits geklontes Projekt.

Git erstellt einen neuen Zweig, der remoteBranchToBeCreatedunter meinen Commits benannt ist, in denen ich gearbeitet habe localBranch.

Bearbeiten : Hiermit wird der localBranchUpstream Ihres aktuellen lokalen Zweigs (möglicherweise benannt ) in geändert origin/remoteBranchToBeCreated. Um dies zu beheben, geben Sie einfach Folgendes ein:

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

Ihre aktuelle lokale Niederlassung wird jetzt origin/localBranchzurückverfolgt.

Ich nehme an, Sie haben bereits ein Projekt geklont wie:

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

1. Erstellen Sie dann in Ihrer lokalen Kopie einen neuen Zweig und checken Sie ihn aus:

   git checkout -b <newbranch>
   

2. Angenommen, Sie haben auf Ihrem Server ein "git bare - init" erstellt und das myapp.git erstellt, sollten Sie:

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

3. Danach sollten Benutzer in der Lage sein

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

HINWEIS: Ich gehe davon aus, dass Ihr Server betriebsbereit ist. Wenn nicht, wird es nicht funktionieren. Eine gute Anleitung finden Sie hier .

HINZUGEFÜGT

Fügen Sie einen Remote-Zweig hinzu:

git push origin master:new_feature_name

Überprüfen Sie, ob alles in Ordnung ist (holen Sie den Ursprung und listen Sie entfernte Zweige auf):

git fetch origin
git branch -r

Erstellen Sie einen lokalen Zweig und verfolgen Sie den Remote-Zweig:

git checkout -tb new_feature_name origin/new_feature_name

Alles aktualisieren:

git pull

veraltet bearbeiten , einfach verwendengit push -u origin $BRANCHNAME

Verwendung git publish-branchvon Williams verschiedenen Git-Tools ( herrliches Repo und Klon) ).

OK, kein Ruby, also - ignoriere die Sicherheitsvorkehrungen! - Nehmen Sie die letzten drei Zeilen des Skripts und erstellen Sie ein Bash-Skript 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}

Führen Sie dann aus git-publish-branch REMOTENAME BRANCHNAME, wobei REMOTENAME normalerweise der Ursprung ist (Sie können das Skript so ändern, dass der Ursprung als Standard verwendet wird usw.)

So erstellen Sie einen neuen Zweig, indem Sie von einem vorhandenen Zweig abzweigen

git checkout -b <new_branch>

und schieben Sie dann diesen neuen Zweig mit in das Repository

git push -u origin <new_branch>

Dadurch werden alle lokalen Commits erstellt und an einen neu erstellten Remote-Zweig weitergeleitet origin/<new_branch>

Verwenden Sie für die GitLab-Version vor 1.7:

git checkout -b name_branch

(name_branch, ex: master)

Gehen Sie folgendermaßen vor, um es in das Remote-Repository zu übertragen:

git push -u origin name_new_branch

(name_new_branch, Beispiel feature)

Ich habe einen Alias ​​erstellt, damit beim Erstellen eines neuen Zweigs der Remote-Zweig entsprechend verschoben und verfolgt wird. Ich habe folgenden Teil in die .bash_profileDatei eingefügt :

# 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

Verwendung : Geben Sie einfach gcb thuy/do-sth-koolmit thuy/do-sth-koolmeinen neuen Filialnamen ein.

Aufbauend auf den Antworten hier habe ich diesen Prozess als einfaches Bash-Skript abgeschlossen, das natürlich auch als Git-Alias ​​verwendet werden kann.

Die wichtige Ergänzung für mich ist, dass ich dadurch aufgefordert werde, vor dem Festschreiben Unit-Tests durchzuführen, und standardmäßig den aktuellen Filialnamen übergebe.

$ 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

Sie können es in 2 Schritten tun:

1. Verwenden Sie checkoutzum Erstellen des lokalen Zweigs:

git checkout -b yourBranchName

Arbeiten Sie mit Ihrer Niederlassung, wie Sie möchten.

2. Verwenden Sie den pushBefehl, um den Zweig automatisch zu erstellen und den Code an das Remote-Repository zu senden:

git push -u origin yourBanchName

Es gibt mehrere Möglichkeiten, dies zu tun, aber ich denke, dass dieser Weg wirklich einfach ist.

Für größtmögliche Flexibilität können Sie einen benutzerdefinierten Git-Befehl verwenden . Erstellen Sie beispielsweise das folgende Python-Skript irgendwo in Ihrem $PATHunter dem Namen git-publishund machen Sie es ausführbar:

#!/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())

Dann git publish -hwerden Ihnen Nutzungsinformationen angezeigt:

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)