Aşağıdakileri yapabilmek istiyorum:

1. Diğer bazı (uzak veya yerel) şube dayalı bir yerel şube (via oluşturma git branchveya git checkout -b)

2. Yerel şubeyi uzak depoya (yayınla) aktarın, ancak izlenebilir hale getirin git pullve git pushhemen çalışacaktır.

Bunu nasıl yaparım?

--set-upstreamGit 1.7'de biliyorum , ama bu bir yaratım sonrası eylem. Şubeyi uzak depoya iterken benzer bir değişiklik yapmanın bir yolunu bulmak istiyorum.

Git 1.7.0 ve sonraki sürümlerinde yeni bir şubeye göz atabilirsiniz:

git checkout -b <branch>

Dosyaları düzenleyin, ekleyin ve uygulayın. Ardından (kısalt ) seçeneğiyle itin-u--set-upstream :

git push -u origin <branch>

Git, itme sırasında izleme bilgilerini ayarlayacaktır.

Repoyu başkalarıyla paylaşmıyorsanız, tüm şubelerinizi uzaktan kumandaya itmek ve --set-upstreamsizin için doğru bir şekilde izlemek yararlıdır :

git push --all -u

(OP'nin tam olarak ne istediğini değil, ama bu tek astar oldukça popülerdir)

Repoyu başkalarıyla paylaşıyorsanız, repoyu tüm tehlikeli deneysel dallarınızla tıkayacağınız için bu gerçekten iyi bir form değildir.

Girişinden önce git push -u, git pusharzu ettiğiniz şeyi elde etme seçeneği yoktu . Yeni yapılandırma ifadeleri eklemeniz gerekiyordu.

Şunu kullanarak yeni bir şube oluşturursanız:

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

git configDoğrudan .git/configdosyayı düzenlemekten kaçınmak için komutu kullanabilirsiniz .

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

Veya .git/configbu şubeyle ilgili izleme bilgilerine sahip olmak için dosyayı manuel olarak düzenleyebilirsiniz .

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

Basitçe söylemek gerekirse, yeni bir yerel şube oluşturmak için şunları yapın:

git branch <branch-name>

Uzak depoya göndermek için şunları yapın:

git push -u origin <branch-name>

Burada zaten verilen çözümlerin küçük bir varyasyonu:

1. Diğer (uzak veya yerel) bir dalı temel alan bir yerel şube oluşturun:

   git checkout -b branchname
   

2. Yerel şubeyi uzak depoya (yayınla) aktarın, ancak izlenebilir hale getirin git pullve git pushhemen çalışın

   git push -u origin HEAD
   

   Kullanmak HEAD, "geçerli dalı uzaktan kumandadaki aynı ada itmek için kullanışlı bir yoldur". Kaynak: https://git-scm.com/docs/git-push Git terimlerinde, HEAD (büyük harf), geçerli dalın (ağacın) tepesine bir referanstır.

   -uSeçenek için sadece kısa --set-upstream. Bu, geçerli dal için yukarı akış izleme referansı ekleyecektir. bunu .git / config dosyanıza bakarak doğrulayabilirsiniz:

   

Basitçe yaparım

git push -u origin localBranch:remoteBranchToBeCreated

zaten klonlanmış bir proje üzerinde.

Git remoteBranchToBeCreatedyaptığım taahhütlerimin altında yeni bir şube oluşturur localBranch.

Düzenle : mevcut yerel şubenizin (muhtemelen adlandırılmış localBranch) akış yukarı olarak değiştirilmesini sağlar origin/remoteBranchToBeCreated. Bunu düzeltmek için şunu yazın:

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

Böylece şu anki yerel şubeniz artık origin/localBranchgeri dönüyor.

Zaten böyle bir projeyi klonladığınızı varsayalım:

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

1. Ardından yerel kopyanızda yeni bir şube oluşturun ve inceleyin:

   git checkout -b <newbranch>
   

2. Sunucunuzda "git bare --init" yaptığınızı ve myapp.git'i oluşturduğunuzu varsayarak, şunları yapmalısınız:

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

3. Bundan sonra, kullanıcılar

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

NOT: Sunucunuzun çalışır durumda olduğunu varsayıyorum. Eğer değilse, çalışmaz. İyi bir nasıl yapılır burada .

KATMA

Uzak bir şube ekle:

git push origin master:new_feature_name

Her şeyin iyi olup olmadığını kontrol edin (başlangıç ​​noktasını getirin ve uzak dalları listeleyin):

git fetch origin
git branch -r

Yerel bir şube oluşturun ve uzak dalı izleyin:

git checkout -tb new_feature_name origin/new_feature_name

Her şeyi güncelleyin:

git pull

düzenlemek Outdated, just usegit push -u origin $BRANCHNAME

Kullanım git publish-branchgelen William'ın muhtelif Git araçları ( gitorious repo ve klon ).

Tamam, Ruby yok, yani - korumaları görmezden gelmek! -, senaryonun son üç satırları alıp bir bash komut dosyası oluşturmak 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}

Ardından git-publish-branch REMOTENAME BRANCHNAME, REMOTENAME öğesinin genellikle kaynak olduğunu çalıştırın (komut dosyasını varsayılan olarak kaynaklanacak şekilde değiştirebilirsiniz, vb.)

Mevcut bir daldan dallayarak yeni bir dal oluşturmak için

git checkout -b <new_branch>

ve sonra bu yeni dalı kullanarak

git push -u origin <new_branch>

Bu, tüm yerel taahhütleri oluşturur ve yeni oluşturulan bir uzak şubeye gönderir origin/<new_branch>

1.7'den önceki GitLab sürümü için şunu kullanın:

git checkout -b name_branch

(name_branch, örn: master)

Uzak depoya göndermek için şunları yapın:

git push -u origin name_new_branch

(name_new_branch, örneğin: feature)

Yeni bir dal oluşturduğumda, uzak dalı da buna göre itecek ve izleyecek şekilde bir takma ad yaptım. Ben .bash_profiledosyaya aşağıdaki yığın koydum :

# 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

Kullanımı : Sadece tipi gcb thuy/do-sth-koolile thuy/do-sth-koolbenim yeni şube adıdır.

Buradaki cevaplara biraz dayanarak, bu süreci elbette Git takma adı olarak da kullanılabilecek basit bir Bash betiği olarak tamamladım.

Benim için önemli olan, bu işlemin taahhütte bulunmadan önce birim testleri yapmamı istemesi ve varsayılan olarak geçerli şube adından geçmesidir.

$ 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

2 adımda yapabilirsiniz:

1.checkout for yerel dal oluşturmak için kullanın :

git checkout -b yourBranchName

Şubenizle istediğiniz gibi çalışın.

2.push Şubeyi otomatik olarak oluşturmak ve kodu uzak depoya göndermek için komutu kullanın :

git push -u origin yourBanchName

Bunu yapmanın birden çok yolu var ama bence bu yol gerçekten basit.

En iyi esneklik için özel bir Git komutu kullanabilirsiniz . Örneğin, adınızın $PATHaltında bir yerde aşağıdaki Python komut dosyasını oluşturun ve git-publishçalıştırılabilir yapın:

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

Sonra git publish -hsize kullanım bilgilerini gösterecektir:

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)