Como nomear e recuperar um esconderijo pelo nome no git?

Eu sempre tive a impressão de que você poderia dar um nome a um stash fazendo git stash save stashname, que você poderia aplicar mais tarde git stash apply stashname. Mas parece que, neste caso, tudo o que acontece é que stashnameserá usado como a descrição do stash.

Não há como realmente nomear um esconderijo? Caso contrário, o que você recomendaria para obter funcionalidade equivalente? Essencialmente, eu tenho um pequeno estoque que gostaria de aplicar periodicamente, mas não quero sempre ter que caçar git stash listqual é o seu número real.

É assim que se faz:

git stash save "my_stash"

Onde "my_stash"está o nome do esconderijo.

Algumas coisas mais úteis a saber: Todos os stashes são armazenados em uma pilha. Tipo:

git stash list

Isso listará todos os seus esconderijos.

Para aplicar um stash e removê-lo da pilha stash, digite:

git stash pop stash@{n}

Para aplicar um stash e mantê-lo na pilha stash, digite:

git stash apply stash@{n}

Onde nestá o índice da alteração oculta.

git stash savefoi descontinuado a partir de 2.15.x / 2.16; em vez disso, você pode usargit stash push -m "message"

Você pode usá-lo assim:

git stash push -m "message"

onde "mensagem" é sua nota para esse esconderijo.

A fim de recuperar o estoque você pode usar: git stash list. Isso produzirá uma lista como esta, por exemplo:

stash@{0}: On develop: perf-spike
stash@{1}: On develop: node v10

Então você simplesmente usa applyo seguinte stash@{index}:

git stash apply stash@{1}

Referências página de manual git stash

Você pode transformar um esconderijo em um galho, se achar que é importante o suficiente:

git stash branch <branchname> [<stash>]

na página do manual:

Isso cria e efetua o check-out de uma nova ramificação denominada <branchname>a partir da confirmação na qual a <stash>criação original foi criada, aplica as alterações registradas na <stash>nova árvore e índice de trabalho e elimina a opção <stash>se for concluída com êxito. Quando não <stash>é dado, aplica o mais recente.

Isso é útil se a ramificação na qual você executou git stash savemudou o suficiente para que a aplicação do git stash falhe devido a conflitos. Como o stash é aplicado na parte superior da confirmação que era HEAD no momento em que o git stash foi executado, ele restaura o estado originalmente stashed sem conflitos.

Mais tarde, você pode refazer esse novo ramo para outro local que descende de onde estava quando se escondeu.

Se você está apenas procurando uma maneira leve de salvar algumas ou todas as alterações atuais na sua cópia de trabalho e depois reaplicá-las à vontade, considere um arquivo de patch:

# save your working copy changes
git diff > some.patch

# re-apply it later
git apply some.patch

De vez em quando eu me pergunto se eu deveria usar esconderijos para isso e depois vejo coisas como a loucura acima e estou contente com o que estou fazendo :)

Os esconderijos não devem ser permanentes como você deseja. Você provavelmente seria melhor servido usando tags em confirmações. Construa o que você deseja esconder. Faça um commit com isso. Crie uma tag para esse commit. Em seguida, reverta sua ramificação paraHEAD^ . Agora, quando você quiser reaplicar esse esconderijo, poderá usar git cherry-pick -n tagname( -né --no-commit).

use git stash push -m aNameForYourStashpara salvá-lo. Em seguida, use git stash listpara aprender o índice do stash que você deseja aplicar. Em seguida, use git stash pop --index 0para abrir o esconderijo e aplicá-lo.

note: estou usando a versão 2.21.0.windows.1 do git

Eu tenho essas duas funções no meu .zshrcarquivo:

function gitstash() {
    git stash push -m "zsh_stash_name_$1"
}

function gitstashapply() {
    git stash apply $(git stash list | grep "zsh_stash_name_$1" | cut -d: -f1)
}

Utilizando-os desta maneira:

gitstash nice

gitstashapply nice

Que tal isso?

git stash save stashname
git stash apply stash^{/stashname}

Alias

sapply = "!f() { git stash apply \"$(git stash list | awk -F: --posix -vpat=\"$*\" \"$ 0 ~ pat {print $ 1; exit}\")\"; }; f"

Uso

git sapply "<regex>"

• compatível com Git para Windows

Edit: Aderi à minha solução original, mas vejo por que a maioria prefere a versão de Etan Reisner (acima). Então, só para constar:

sapply = "!f() { git stash apply \"$(git stash list | grep -E \"$*\" | awk \"{ print $ 1; }\" | sed -n \"s/://;1p\")\"; }; f"

É uma pena que git stash apply stash^{/<regex>}isso não funcione (na verdade, ele não pesquisa na lista stash, veja os comentários na resposta aceita ).

Aqui estão as substituições drop-in que pesquisam git stash listpor regex para encontrar o primeiro (mais recente) stash@{<n>}e depois o passam para git stash <command>:

# standalone (replace <stash_name> with your regex)
(n=$(git stash list --max-count=1 --grep=<stash_name> | cut -f1 -d":") ; if [[ -n "$n" ]] ; then git stash show "$n" ; else echo "Error: No stash matches" ; return 1 ; fi)
(n=$(git stash list --max-count=1 --grep=<stash_name> | cut -f1 -d":") ; if [[ -n "$n" ]] ; then git stash apply "$n" ; else echo "Error: No stash matches" ; return 1 ; fi)

# ~/.gitconfig
[alias]
  sshow = "!f() { n=$(git stash list --max-count=1 --grep=$1 | cut -f1 -d":") ; if [[ -n "$n" ]] ; then git stash show "$n" ; else echo "Error: No stash matches $1" ; return 1 ; fi }; f"
  sapply = "!f() { n=$(git stash list --max-count=1 --grep=$1 | cut -f1 -d":") ; if [[ -n "$n" ]] ; then git stash apply "$n" ; else echo "Error: No stash matches $1" ; return 1 ; fi }; f"

# usage:

$ git sshow my_stash
 myfile.txt | 1 +
 1 file changed, 1 insertion(+)

$ git sapply my_stash
On branch master
Your branch is up to date with 'origin/master'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   myfile.txt

no changes added to commit (use "git add" and/or "git commit -a")

Observe que os códigos de resultado adequados são retornados para que você possa usar esses comandos em outros scripts. Isso pode ser verificado após a execução de comandos com:

echo $?

Apenas tome cuidado com explorações de expansão variável, porque eu não tinha certeza sobre a --grep=$1parte. Talvez devesse ser, --grep="$1"mas não tenho certeza se isso interferiria nos delimitadores de expressões regulares (estou aberto a sugestões).

Esta resposta deve muito a Klemen Slavič. Eu teria acabado de comentar a resposta aceita, mas ainda não tenho representante suficiente :(

Você também pode adicionar um alias do git para encontrar o ref do stash e usá-lo em outros aliases para mostrar, aplicar, soltar etc.

[alias]
    sgrep = "!f() { ref=$(git --no-pager stash list | grep "$1" | cut -d: -f1 | head -n1); echo ${ref:-<no_match>}; }; f"
    sshow = "!f() { git stash show $(git sgrep "$1") -p; }; f"
    sapply = "!f() { git stash apply $(git sgrep "$1"); }; f"
    sdrop = "!f() { git stash drop $(git sgrep "$1"); }; f"

Observe que o motivo do ref=$( ... ); echo ${ref:-<no_match>};padrão é que uma string em branco não seja retornada, o que causaria ao sshow, sapply e sdrop direcionar o stash mais recente em vez de falhar, como seria de esperar.

Alias Essa pode ser uma sintaxe mais direta para sistemas similares ao Unix, sem a necessidade de encapsular uma função. Adicione o seguinte a ~ / .gitconfig em [alias]

sshow = !sh -c 'git stash show stash^{/$*} -p' -
sapply = !sh -c 'git stash apply stash^{/$*}' -
ssave = !sh -c 'git stash save "${1}"' -

Uso: sapply regex

Exemplo: git sshow MySecretStash

O hífen no final diz receber informações da entrada padrão.

Use um pequeno script bash para procurar o número do stash. Chame de "gitapply":

NAME="$1"
if [[ -z "$NAME" ]]; then echo "usage: gitapply [name]"; exit; fi
git stash apply $(git stash list | grep "$NAME" | cut -d: -f1)

Uso:

gitapply foo

... onde foo é uma subcadeia do nome do esconderijo que você deseja.

Usar git stash save NAME para salvar.

Então ... você pode usar este script para escolher qual aplicar (ou pop):

#!/usr/bin/env ruby
#git-stash-pick by Dan Rosenstark

# can take a command, default is apply
command = ARGV[0]
command = "apply" if !command
ARGV.clear

stashes = []
stashNames = []
`git stash list`.split("\n").each_with_index { |line, index|
    lineSplit = line.split(": ");
    puts "#{index+1}. #{lineSplit[2]}"
    stashes[index] = lineSplit[0]
    stashNames[index] = lineSplit[2]
}
print "Choose Stash or ENTER to exit: "
input = gets.chomp
if input.to_i.to_s == input
    realIndex = input.to_i - 1
    puts "\n\nDoing #{command} to #{stashNames[realIndex]}\n\n"
    puts `git stash #{command} #{stashes[realIndex]}`
end

Eu gosto de poder ver os nomes dos esconderijos e escolher. Também uso o Zshell e, francamente, não sabia como usar alguns dos aliases do Bash acima;)

Nota: Como Kevin diz, você deve usar tags e cherry picks.

Esta é uma maneira de fazer isso usando o PowerShell:

<#
.SYNOPSIS
Restores (applies) a previously saved stash based on full or partial stash name.

.DESCRIPTION
Restores (applies) a previously saved stash based on full or partial stash name and then optionally drops the stash. Can be used regardless of whether "git stash save" was done or just "git stash". If no stash matches a message is given. If multiple stashes match a message is given along with matching stash info.

.PARAMETER message
A full or partial stash message name (see right side output of "git stash list"). Can also be "@stash{N}" where N is 0 based stash index.

.PARAMETER drop
If -drop is specified, the matching stash is dropped after being applied.

.EXAMPLE
Restore-Stash "Readme change"
Apply-Stash MyStashName
Apply-Stash MyStashName -drop
Apply-Stash "stash@{0}"
#>
function Restore-Stash  {
    [CmdletBinding()]
    [Alias("Apply-Stash")]
    PARAM (
        [Parameter(Mandatory=$true)] $message,         
        [switch]$drop
    )

    $stashId = $null

    if ($message -match "stash@{") {
        $stashId = $message
    }

    if (!$stashId) {
        $matches = git stash list | Where-Object { $_ -match $message }

        if (!$matches) {
            Write-Warning "No stashes found with message matching '$message' - check git stash list"
            return
        }

        if ($matches.Count -gt 1) {
            Write-Warning "Found $($matches.Count) matches for '$message'. Refine message or pass 'stash{@N}' to this function or git stash apply"
            return $matches
        }

        $parts = $matches -split ':'
        $stashId = $parts[0]
    }

    git stash apply ''$stashId''

    if ($drop) {
        git stash drop ''$stashId''
    }
}

Mais detalhes aqui

na minha concha de peixe

function gsap
  git stash list | grep ": $argv" | tr -dc '0-9' | xargs git stash apply
end

usar

gsap name_of_stash

Tarde para a festa aqui, mas se você estiver usando o VSCode, uma maneira rápida de fazer isso é abrir a paleta de comandos (CTRL / CMD + SHIFT + P) e digitar "Pop Stash", você poderá recuperar o seu stash pelo nome sem a necessidade de usar git CLI

git stash applytambém funciona com outros árbitros que não stash@{0}. Portanto, você pode usar tags comuns para obter um nome persistente. Isso também tem a vantagem de você não poder acidentalmente git stash dropougit stash pop isso.

Então você pode definir um alias pstash(também conhecido como "stash persistente") como este:

git config --global alias.pstash '!f(){ git stash && git tag "$1" stash && git stash drop; }; f'

Agora você pode criar um stash marcado:

git pstash x-important-stuff

e showe apply-lo novamente como de costume:

git stash show x-important-stuff
git stash apply x-important-stuff

Eu não acho que haja uma maneira de colocar um esconderijo com seu nome.

Eu criei uma função bash que faz isso.

#!/bin/bash

function gstashpop {
  IFS="
"
  [ -z "$1" ] && { echo "provide a stash name"; return; }
  index=$(git stash list | grep -e ': '"$1"'$' | cut -f1 -d:)
  [ "" == "$index" ] && { echo "stash name $1 not found"; return; }
  git stash apply "$index"
}

Exemplo de uso:

[~/code/site] on master*
$ git stash push -m"here the stash name"
Saved working directory and index state On master: here the stash name

[~/code/site] on master
$ git stash list
stash@{0}: On master: here the stash name

[~/code/site] on master
$ gstashpop "here the stash name"

Espero que ajude!

Para tudo, além da criação do stash, eu proporia outra solução introduzindo o fzf como uma dependência. Eu recomendo que você dedique 5 minutos do seu tempo e seja apresentado a ele, pois é um grande impulsionador da produtividade.

De qualquer forma, um trecho relacionado da página de exemplos oferece pesquisa de esconderijo. É muito fácil alterar o scriptlet para adicionar funcionalidades adicionais (como aplicação stash ou dropping):

fstash() {
    local out q k sha
    while out=$(
            git stash list --pretty="%C(yellow)%h %>(14)%Cgreen%cr %C(blue)%gs" |
            fzf --ansi --no-sort --query="$q" --print-query \
                --expect=ctrl-d,ctrl-b); do
        mapfile -t out <<< "$out"
        q="${out[0]}"
        k="${out[1]}"
        sha="${out[-1]}"
        sha="${sha%% *}"
        [[ -z "$sha" ]] && continue
        if [[ "$k" == 'ctrl-d' ]]; then
            git diff $sha
        elif [[ "$k" == 'ctrl-b' ]]; then
            git stash branch "stash-$sha" $sha
            break;
        else
            git stash show -p $sha
        fi
    done
}

Portanto, não sei por que há tanta consternação nesse tópico. Posso nomear um stash com um push e o save obsoleto, e posso usar um regex para recuperá-lo com uma aplicação:

Método stash Git para usar um nome para aplicar

$ git stash push -m "john-hancock"

$ git stash apply stash^{/john-hancock}

Como mencionado anteriormente, o comando save foi descontinuado, mas ainda funciona, portanto, você pode usá-lo em sistemas mais antigos, onde não pode atualizá-los com uma chamada por push. Diferente do comando push, a opção -m não é necessária com o save.

// save is deprecated but still functional  
$ git stash save john-hancock

Problemas com um pop e drop

Não acredito que funcione com um pop, mas acho que é porque o pop executa uma queda após a aplicação e o regex não é amigável com a queda. Isso é apenas um palpite. Eu não testei.

Este é o Git 2.2 e o Windows 10.

Prova Visual

Aqui está um belo GIF animado demonstrando o processo.

Sequência de eventos

O GIF é executado rapidamente, mas se você olhar, o processo é o seguinte:

1. O comando ls mostra 4 arquivos no diretório
2. touch example.html adiciona um quinto arquivo
3. git stash push -m "john-hancock" -a (O -a inclui arquivos não rastreados)
4. O comando ls mostra 4 arquivos após o stash, o que significa que o stash e a reinicialização implícita do disco funcionaram
5. git stash apply stash ^ {/ john-hancock} roda
6. O comando ls lista 5 arquivos, mostrando que o arquivo example.html foi trazido de volta, o que significa que o comando git stash apply funcionou.

Isso faz algum sentido?

Para ser franco, não tenho certeza de qual é o benefício dessa abordagem. É importante dar um nome ao esconderijo, mas não a recuperação. Talvez para criar um script do processo, seria útil, mas ainda é muito mais fácil colocar um esconderijo por nome.

$ git stash pop 3
$ git stash apply 3

Isso me parece muito mais fácil do que o regex.