Invierte un trozo en Magit 2.1.0

Acabo de actualizar a magit 2.1.0. (Y también a emacs 25.0.50 y git 2.3.1.)

Anteriormente, en el *magit*búfer pude:

1. Seleccione un trozo en el área Sin clasificar.
2. Escriba vy responda sí para revertirlo.

Esto fue útil.

Pero ahora en Magit 2.1.0 se da un error: "Cannot reverse unstaged changes".

¿Por qué?

Tomando una pista del mensaje de error, descubrí que aún puedo hacer esto, aunque de una manera algo "al revés" con más pasos:

1. sTage el trozo. (Se siente hacia atrás; acercándolo al estado comprometido).
2. Navegue hacia abajo y selecciónelo en el área por etapas.
3. Presione v, responda sí.
4. Sin embargo, el trozo todavía está en escena, así que finalmente tengo que poner en uescena el trozo.

¿Es esto un error, o es intencional y / o estoy siendo denso? Si es esto último, ¿puedes ayudarme a entender?

ACTUALIZACIÓN: Después de exhaustivamente RTFinfo, veo que hay dos comandos:

• v magit-reverse Invierta el cambio en el punto del árbol de trabajo.
• k magit-discard Elimine el cambio en el punto del árbol de trabajo.

Parece que k magit-discardhace lo que estaba acostumbrado a vhacer antes. Funciona en un trozo sin escena.

Así que prácticamente solo necesito volver a entrenar mi memoria muscular para usar k. Podría publicar eso como una respuesta propia. Pero supongo que todavía tengo curiosidad sobre el fundamento, porque imagino que comprenderlo me ayudará a comprender mejor el talento en general.

Magit implementa cinco "variantes de aplicación" descritas en el manual : etapa, unstage, "aplicación regular", descartar e invertir. Los primeros tres deberían ser bastante obvios para la mayoría de los usuarios de Git. Los dos últimos no existen en la porcelana Git (en Magit se implementan utilizando comandos de fontanería Git y Emacs Lisp).

Estas dos variantes se describen así:

• Descarte. En un cambio por etapas, elimínelo del árbol de trabajo y del índice. En un cambio no organizado, elimínelo solo del árbol de trabajo.
• Marcha atrás. Invierta un cambio en el árbol de trabajo. Tanto los cambios comprometidos como los organizados pueden revertirse. Los cambios sin clasificar no se pueden revertir. Descartarlos en su lugar.

Estas dos variantes hacen cosas muy diferentes, por lo que ninguna de estas variantes debería recurrir a la otra variante en los casos en que no se pueda utilizar. Mantener el comportamiento anterior (de retroceder de reverso a descarte en algunos contextos) podría haber sido más conveniente a corto plazo, pero a largo plazo evita que los usuarios realmente intenten comprender para qué sirven estas dos variantes.

Descartar es mucho más peligroso que revertir . El primero "desecha los cambios no confirmados" (estos cambios se pierden, ya no están en ninguna parte), mientras que el segundo en realidad "crea cambios", al tomar un cambio anterior y hacer lo contrario en el árbol de trabajo (el cambio anterior no se pierde, todavía está en una confirmación o el índice).

Retroceder de "crear" a "eliminar" es muy peligroso, por lo que Magit ya no hace eso.

También tenga en cuenta que al usar los nuevos modos wip puede protegerse de la pérdida de cambios debido a un descarte accidental.

Parece que accidentalmente aprendí que v, sin duda magit-revert-item, solía hacer algo magit-discard-itemen este caso especial de trozos sin escena. Vea el <=== HERE ===comentario que pongo a continuación:

(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")))))

Fuente: código 1.4.2 .

Pero ahora eso no sucede:

(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)))))

Fuente: maestro :

Sin embargo, kestá vinculado directamente a magit-discard-item. Debería haber aprendido a usar eso en primer lugar. Eso funcionó antes de 2.1.0, y aún funciona.

En conclusión, magit 2.1.0 ha sido significativamente rediseñado. Es inevitable que algunos casos extraños en las esquinas no hayan sobrevivido. Y, estoy de acuerdo, no necesito haber sobrevivido. Volveré a aprender la llave.