Inverter um pedaço no Magit 2.1.0

Acabei de atualizar para o magit 2.1.0. (E também para emacs 25.0.50 e git 2.3.1.)

Anteriormente, no *magit*buffer eu podia:

1. Selecione um pedaço na área Sem estágio.
2. Digite ve responda yes para inverter.

Isso foi útil.

Mas agora, em magit 2.1.0 ele dá um erro: "Cannot reverse unstaged changes".

Por quê?

Tomando uma dica da mensagem de erro, descobri que ainda posso fazer isso, embora de maneira um pouco "retrógrada" com mais etapas:

1. sprenda o pedaço. (Sente-se para trás; aproximando-o do estado comprometido.)
2. Navegue para baixo e selecione-o na área Preparado.
3. Pressione v, responda sim.
4. No entanto, o pedaço ainda está encenado, então finalmente eu tenho que uencenar o pedaço.

Isso é um bug ou é intencional e / ou estou sendo denso? Neste último caso, você pode me ajudar a entender?

ATUALIZAÇÃO: Após o RTFinfo completamente, vejo que existem dois comandos:

• v magit-reverse Inverta a alteração no ponto da árvore de trabalho.
• k magit-discard Remova a alteração no ponto da árvore de trabalho.

Parece que k magit-discardfaz o que eu estava acostumado a vfazer antes. Ele funciona em um pedaço não-encenado.

Então, praticamente, eu só preciso treinar minha memória muscular para usar k. Eu poderia postar isso como uma resposta automática. Mas acho que ainda estou curioso sobre a lógica, porque imagino que entendê-la me ajudará a entender melhor o magit.

O Magit implementa cinco "variantes de aplicação" descritas no manual : estágio, instável, "aplicação regular", descarte e reversão. Os três primeiros devem ser bastante óbvios para a maioria dos usuários do Git. Os dois últimos não existem na porcelana Git (no Magit, eles são implementados usando os comandos de encanamento Git e Emacs Lisp).

Essas duas variantes são descritas assim:

• Descartar. Em uma alteração faseada, remova-a da árvore de trabalho e do índice. Em uma alteração não faseada, remova-a apenas da árvore de trabalho.
• Marcha ré. Inverta uma alteração na árvore de trabalho. Alterações confirmadas e faseadas podem ser revertidas. Alterações não faseadas não podem ser revertidas. Descarte-os em seu lugar.

Essas duas variantes fazem coisas muito diferentes; portanto, nenhuma dessas variantes deve voltar para a outra variante nos casos em que ela mesma não pode ser usada. Manter o comportamento antigo (de recuar do reverso para o descarte em alguns contextos) pode ter sido mais conveniente a curto prazo, mas a longo prazo evita que os usuários realmente tentem entender para que servem essas duas variantes.

Descartar é muito mais perigoso que reverter . O primeiro "joga fora as alterações não confirmadas" (essas mudanças são perdidas, não estão mais em lugar nenhum), enquanto o último "cria mudanças", fazendo uma alteração mais antiga e fazendo o oposto na área de trabalho (a mudança antiga não é perdida, ainda está em uma confirmação ou no índice).

Voltar de "criar" para "excluir" é muito perigoso, portanto o Magit não faz mais isso.

Observe também que, usando os novos modos de limpeza, você pode se proteger contra a perda de alterações devido a um descarte acidental.

Parece que eu aprendi acidentalmente que v, vinculado a magit-revert-item, costumava fazer um magit-discard-itemneste caso especial de pedaços não-encenados. Veja o <=== HERE ===comentário que coloquei abaixo:

(defun magit-revert-item ()
  "Revert the item at point.
The change introduced by the item is reversed in the current
working tree."
  (interactive)
  (magit-section-action revert (info)
    ([* unstaged] (magit-discard-item))  ;; <=== HERE ===
    (commit (when (or (not magit-revert-item-confirm)
                      (yes-or-no-p "Revert this commit? "))
              (magit-revert-commit info)))
    (diff   (when (or (not magit-revert-item-confirm)
                      (yes-or-no-p "Revert this diff? "))
              (magit-apply-diff-item it "--reverse")))
    (hunk   (when (or (not magit-revert-item-confirm)
                      (yes-or-no-p "Revert this hunk? "))
              (magit-apply-hunk-item it "--reverse")))))

Fonte: código 1.4.2 .

Mas agora isso não acontece:

(defun magit-reverse (&rest args)
  "Reverse the change at point in the working tree."
  (interactive (and current-prefix-arg (list "--3way")))
  (--when-let (magit-current-section)
    (pcase (list (magit-diff-type) (magit-diff-scope))
      (`(untracked ,_) (user-error "Cannot reverse untracked changes"))
      (`(unstaged  ,_) (user-error "Cannot reverse unstaged changes"))
      (`(,_      list) (magit-reverse-files (magit-section-children it) args))
      (`(,_     files) (magit-reverse-files (magit-region-sections) args))
      (`(,_      file) (magit-reverse-files (list it) args))
      (_               (magit-reverse-apply it args)))))

Fonte: master :

No entanto, ké vinculado diretamente a magit-discard-item. Eu deveria ter aprendido a usar isso em primeiro lugar. Isso funcionou antes da versão 2.1.0 e ainda funciona.

Em conclusão, o magit 2.1.0 foi redesenhado significativamente. É inevitável que alguns casos estranhos nos cantos não tenham sobrevivido. E, eu concordo, não precisa ter sobrevivido. Vou reaprender a chave.