Aggiunta del ramo git al prompt dei comandi di Bash

Ho provato ad aggiungere il ramo git su cui sto attualmente lavorando (estratto) sul prompt di bash senza successo .. ( pur mantenendo intatto il mio percorso corrente che mostra la directory / il file attivi ) Ho un file .bashrc a casa mia, ma ho anche visto molte persone menzionare il file .profile ..

git 1.9.3 o successivo: usare __git_ps1

Git fornisce uno script shell chiamato git-prompt.sh, che include una funzione __git_ps1che

stampa il testo da aggiungere al prompt di bash PS1 (include il nome del ramo)

Il suo utilizzo più semplice è:

$ __git_ps1
(master)

Prende anche una stringa di formato opzionale:

$ __git_ps1 'git:[%s]'
git:[master]

Come ottenerlo

Innanzitutto, copia il file da qualche parte (ad es ~/.git-prompt.sh.).

Opzione 1: usa una copia esistente sul tuo filesystem. Esempio (Mac OS X 10.15):

$ find / -name 'git-prompt.sh' -type f -print -quit 2>/dev/null
/Library/Developer/CommandLineTools/usr/share/git-core/git-prompt.sh

Opzione 2: estrarre lo script da GitHub .

Quindi, aggiungi la seguente riga al tuo .bashrc/.zshrc:

source ~/.git-prompt.sh

Infine, cambia il tuo PS1per chiamare __git_ps1come sostituzione di comando:

bash:

PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '

zsh:

setopt PROMPT_SUBST ; PS1='[%n@%m %c$(__git_ps1 " (%s)")]\$ '

git <1.9.3

Ma nota che solo git 1.9.3 (maggio 2014) o successivo ti permette di mostrare in modo sicuro quel nome di ramo (!)

Vedi commit 8976500 di Richard Hansen ( richardhansen) :

Sia bash che zsh sottopongono il valore di PS1 all'espansione dei parametri , alla sostituzione dei comandi e all'espansione aritmetica.

Invece di includere il nome del ramo grezzo e senza caratteri di escape PS1quando si esegue in modalità a due o tre argomenti, costruire PS1per fare riferimento a una variabile che contiene il nome del ramo.

Poiché le shell non si espandono in modo ricorsivo, questo evita l'esecuzione di codice arbitrario da nomi di rami appositamente predisposti come

'$(IFS=_;cmd=sudo_rm_-rf_/;$cmd)'.

Quale mente subdola chiamerebbe un ramo del genere? ;) ( Accanto a una mamma come in xkcd )

Altri esempi

still_dreaming_1 riporta nei commenti :

Questo sembra funzionare alla grande se vuoi un prompt dei colori con xterm(nel mio .bashrc):

PS1='\[\e]0;\u@\h: \w\a\]\n${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\03‌​3[01;34m\]\w\[\033[00m\]$(__git_ps1)\$ ' 

Tutto ha un colore diverso, incluso il ramo.

In in Linux Mint 17.3 Cinnamon 64-bit:

PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[01;34m\] \w\[\033[00m\]$(__git_ps1) \$ ' 

Seguire i passaggi come di seguito: (Linux)

Modifica il file ~/.bashrc, per inserire le seguenti righe alla fine (Nel caso, di Mac, il file sarebbe ~/.bash_profile)

# Git branch in prompt.
parse_git_branch() {
    git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}
export PS1="\u@\h \W\[\033[32m\]\$(parse_git_branch)\[\033[00m\] $ "

Ora avvia la nuova finestra del terminale e prova ad accedere a qualsiasi git-repo. Verrà mostrato il ramo corrente, con il prompt.

4 Ulteriori informazioni - MAC / Linux

1- Se non hai il completamento bash ...:sudo apt-get install bash-completion

2- Modifica il tuo file .bashrc e seleziona (o aggiungi):

if [ -f /etc/bash_completion ]; then
  . /etc/bash_completion
fi

3- ... prima della riga di comando : export PS1='$(__git_ps1) \w\$ '
( __git_ps1 mostrerà il tuo ramo git)

4- do source .bashrc

MODIFICARE :

Ulteriori letture: non reinventare la ruota

Ecco come ho configurato il prompt per visualizzare lo stato di Git:

Ottieni script git-prompt:

curl -o ~/.git-prompt.sh https://raw.githubusercontent.com/git/git/master/contrib/completion/git-prompt.sh

E personalizza il tuo prompt aggiungendo il seguente codice nel tuo file .bashrc:

# Load Git functions
source ~/.git-prompt.sh

# Syntactic sugar for ANSI escape sequences
txtblk='\e[0;30m' # Black - Regular
txtred='\e[0;31m' # Red
txtgrn='\e[0;32m' # Green
txtylw='\e[0;33m' # Yellow
txtblu='\e[0;34m' # Blue
txtpur='\e[0;35m' # Purple
txtcyn='\e[0;36m' # Cyan
txtwht='\e[0;37m' # White
bldblk='\e[1;30m' # Black - Bold
bldred='\e[1;31m' # Red
bldgrn='\e[1;32m' # Green
bldylw='\e[1;33m' # Yellow
bldblu='\e[1;34m' # Blue
bldpur='\e[1;35m' # Purple
bldcyn='\e[1;36m' # Cyan
bldwht='\e[1;37m' # White
unkblk='\e[4;30m' # Black - Underline
undred='\e[4;31m' # Red
undgrn='\e[4;32m' # Green
undylw='\e[4;33m' # Yellow
undblu='\e[4;34m' # Blue
undpur='\e[4;35m' # Purple
undcyn='\e[4;36m' # Cyan
undwht='\e[4;37m' # White
bakblk='\e[40m'   # Black - Background
bakred='\e[41m'   # Red
badgrn='\e[42m'   # Green
bakylw='\e[43m'   # Yellow
bakblu='\e[44m'   # Blue
bakpur='\e[45m'   # Purple
bakcyn='\e[46m'   # Cyan
bakwht='\e[47m'   # White
txtrst='\e[0m'    # Text Reset

# Prompt variables
PROMPT_BEFORE="$txtcyn\u@\h $txtwht\w$txtrst"
PROMPT_AFTER="\\n\\\$ "

# Prompt command
PROMPT_COMMAND='__git_ps1 "$PROMPT_BEFORE" "$PROMPT_AFTER"'

# Git prompt features (read ~/.git-prompt.sh for reference)
export GIT_PS1_SHOWDIRTYSTATE="true"
export GIT_PS1_SHOWSTASHSTATE="true"
export GIT_PS1_SHOWUNTRACKEDFILES="true"
export GIT_PS1_SHOWUPSTREAM="auto"
export GIT_PS1_SHOWCOLORHINTS="true"

Se vuoi saperne di più, puoi ottenere tutti i dotfile qui: https://github.com/jamming/dotfiles

Per mac, funziona davvero bene: http://martinfitzpatrick.name/article/add-git-branch-name-to-terminal-prompt-mac/ :

# Git branch in prompt.
parse_git_branch() {
    git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}

export PS1="\u@\h \W\[\033[32m\]\$(parse_git_branch)\[\033[00m\] $ "

All'inizio, apri il tuo profilo Bash nella tua home directory. Il modo più semplice per aprire e modificare il tuo bash_profile usando l'editor predefinito.

Ad esempio, lo apro usando il codice VS usando questo comando: code .bash_profile.

Quindi incolla i seguenti codici su Bash.

parse_git_branch() {
     git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}

export PS1="\u@\h \W\[\033[32m\]\$(parse_git_branch)\[\033[00m\] $ "

La funzione

parse_git_branch ()

recupererà il nome del ramo e poi tramite PS1 puoi mostrarlo nel tuo terminale.

Qui,

\ u = Nome utente

@ = Testo statico

\ h = Nome computer

\ w = Directory corrente

$ = Testo statico

È possibile modificare o rimuovere queste variabili per una maggiore personalizzazione.

Se usi Git per la prima volta nel terminale o immediatamente dopo la configurazione, forse a volte non riesci a vedere il nome del ramo.

Se riscontri questo problema, non preoccuparti. In tal caso, basta creare un repository di esempio e impegnarlo dopo alcune modifiche. Quando il comando commit verrà eseguito una volta, il terminale troverà il ramo git da allora.

vim ~/.bash

parse_git_branch() {
     git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}

export PS1="\u@\h \[\033[32m\]\w\[\033[33m\]\$(parse_git_branch)\[\033[00m\] $"

Per riflettere le ultime modifiche, eseguire il comando seguente

source ~/.bashrc

Produzione:-

chandrakant@NDL41104 ~/Chandrakant/CodeBase/LaravelApp (development) $

Se usi la conchiglia è abbastanza semplice. il pesce è un guscio interattivo che viene fornito con un sacco di chicche. Puoi installarlo usando apt-get.

sudo apt-get install fish

è quindi possibile modificare l'impostazione del prompt utilizzando

> fish_config 
Web config started at 'http://localhost:8001/'. Hit enter to stop.
Created new window in existing browser session.

ora vai ad http://localhost:8001/ aprire la scheda del prompt e scegli l'opzione classica + git

Ora fai clic sul pulsante di richiesta d'uso e sei pronto.

parse_git_branch() {
    git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}
export PS1='\[\e]0;\w\a\]\n\[\e[32m\]\u@\h \[\e[33m\]\w\[\e[0m\]$(parse_git_branch)\n\$ '

Segui i passaggi seguenti per mostrare il nome del ramo del tuo repository GIT nel terminale Ubuntu:

step1: apri il terminale e modifica .bashrc usando il seguente comando.

vi .bashrc

step2: aggiungi la seguente riga alla fine del file .bashrc:

parse_git_branch() {
git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/' }

export PS1="\u@\h \W\[\033[32m\]\$(parse_git_branch)\[\033[00m\] $ "

step3: sorgente .bashrc nella directory principale (home) facendo:

/ RootFolder: ~ $ source .bashrc

Passaggio 4: riavviare e aprire il terminale e controllare il cmd. Passare al percorso della directory del repository GIt e il gioco è fatto. :)

root:~/project#  -> root:~/project(dev)# 

aggiungi il seguente codice alla fine del tuo ~ / .bashrc

force_color_prompt=yes
color_prompt=yes
parse_git_branch() {
git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1)/'
}
if [ "$color_prompt" = yes ]; then
PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[01;31m\]$(parse_git_branch)\[\033[00m\]\$ '
else
PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w$(parse_git_branch)\$ '
fi
unset color_prompt force_color_prompt

Ecco una semplice versione pulita che uso: link

Ho provato un piccolo script in Python che va in una cartella bin .... file 'gitprompt'

#!/usr/bin/env python
import subprocess, os
s = os.path.join(os.getcwd(), '.git')
def cut(cmd):
    ret=''
    half=0
    record = False
    for c in cmd:
        if c == "\n":
            if not (record):
                pass
            else:
                break
        if (record) and c!="\n":
            ret = ret + c
        if c=='*':
            half=0.5
        if c==' ':
            if half == 0.5:
                half = 1
        if half == 1:
            record = True
    return ret
if (os.path.isdir(s)):
    out = subprocess.check_output("git branch",shell=True)
    print cut(out)
else:
    print "-"

Renderlo eseguibile e cose del genere

Quindi regola il prompt di bash di conseguenza come:

\u:\w--[$(gitprompt)] \$